From 7da2b4415fb3109f2c61cbde768c1ca094688259 Mon Sep 17 00:00:00 2001 From: Chris Date: Mon, 18 Aug 2025 09:46:18 +0200 Subject: [PATCH] - Initial commit of base firmware - which is still very raw --- Firmware/.gitignore | 2 + Firmware/.vscode/c_cpp_properties.json | 22 + Firmware/.vscode/cmake-kits.json | 15 + Firmware/.vscode/extensions.json | 9 + Firmware/.vscode/launch.json | 50 + Firmware/.vscode/settings.json | 40 + Firmware/.vscode/tasks.json | 86 + Firmware/CMakeLists.txt | 114 + Firmware/Display.c | 2178 +++++++++++++++++ Firmware/Display.h | 63 + Firmware/Display_Color.c | 127 + Firmware/Display_Color.h | 31 + Firmware/Display_Config.h | 306 +++ Firmware/Display_Default_Configurations.c | 214 ++ Firmware/Display_Default_Configurations.h | 34 + Firmware/Display_Font.c | 169 ++ Firmware/Display_Font.h | 36 + Firmware/Display_Image.c | 403 +++ Firmware/Display_Image.h | 48 + Firmware/Display_Init.c | 240 ++ Firmware/Display_Init.h | 35 + Firmware/Display_Message_Box_Icons.c | 414 ++++ Firmware/Display_Message_Box_Icons.h | 41 + Firmware/Display_Objects.c | 1465 +++++++++++ Firmware/Display_Objects.h | 106 + Firmware/Display_Objects_Datatypes.h | 669 +++++ Firmware/Display_SPI.c | 189 ++ Firmware/Display_SPI.h | 47 + Firmware/Display_Shapes.c | 760 ++++++ Firmware/Display_Shapes.h | 47 + Firmware/Display_Touch.c | 532 ++++ Firmware/Display_Touch.h | 50 + Firmware/Easings.c | 271 ++ Firmware/Easings.h | 80 + Firmware/Fonts/Font_DejaVu_Sans_Mono_10x17.c | 109 + Firmware/Fonts/Font_DejaVu_Sans_Mono_20x34.c | 109 + Firmware/Fonts/Font_DejaVu_Sans_Mono_6x12.c | 109 + .../Fonts/Font_DejaVu_Sans_Mono_Bold_15x26.c | 109 + Firmware/I2C_Master.c | 160 ++ Firmware/I2C_Master.h | 39 + Firmware/INA260.c | 98 + Firmware/INA260.h | 25 + Firmware/Images/Icons_Settings.xcf | Bin 0 -> 45221 bytes .../Image_Bronze_Copper_Microchip2_64x64.c | 75 + Firmware/Images/Image_Computer_64x64.c | 75 + Firmware/Images/Image_Energy_64x64.c | 75 + .../Image_Fad_Logo_Background_160x160.c | 171 ++ .../Images/Image_Forest_Pine_Midi_64x64.c | 75 + .../Images/Image_Midnight_Blue_Back_64x64.c | 75 + Firmware/Images/Image_Music_64x64.c | 75 + .../Images/Image_Olive_Sage_Diskette_64x64.c | 75 + .../Images/Image_Rust_Orange_About1_64x64.c | 75 + Firmware/Images/Image_Setting_64x64.c | 75 + .../Images/Image_Steel_Blue_Jam_Happy_64x64.c | 75 + .../Images/Image_Stone_Blue_Light_On_64x64.c | 75 + Firmware/Rotary_Encoder.c | 141 ++ Firmware/Rotary_Encoder.h | 32 + Firmware/Screen_Variables.c | 24 + Firmware/Screens.h | 47 + Firmware/Screens_Display/Screen_Loading.c | 362 +++ Firmware/Screens_Display/Screen_Menu_Main.c | 196 ++ Firmware/Screens_Display/Screen_Select_RGB.c | 146 ++ Firmware/Screens_Display/Screen_Settings.c | 176 ++ Firmware/UI_Control.c | 262 ++ Firmware/UI_Control.h | 65 + Firmware/USB_Serial.c | 166 ++ Firmware/USB_Serial.h | 43 + Firmware/build/.gitignore | 4 + Firmware/build/Pico_Reset_And_Program.py | 189 ++ Firmware/build/build_number.txt | 1 + Firmware/build/build_version.txt | 1 + Firmware/build/increment_build_number.bat | 26 + Firmware/build/pico_program_auto.bat | 49 + Firmware/main.c | 174 ++ Firmware/pico_sdk_import.cmake | 121 + 75 files changed, 12872 insertions(+) create mode 100644 Firmware/.gitignore create mode 100644 Firmware/.vscode/c_cpp_properties.json create mode 100644 Firmware/.vscode/cmake-kits.json create mode 100644 Firmware/.vscode/extensions.json create mode 100644 Firmware/.vscode/launch.json create mode 100644 Firmware/.vscode/settings.json create mode 100644 Firmware/.vscode/tasks.json create mode 100644 Firmware/CMakeLists.txt create mode 100644 Firmware/Display.c create mode 100644 Firmware/Display.h create mode 100644 Firmware/Display_Color.c create mode 100644 Firmware/Display_Color.h create mode 100644 Firmware/Display_Config.h create mode 100644 Firmware/Display_Default_Configurations.c create mode 100644 Firmware/Display_Default_Configurations.h create mode 100644 Firmware/Display_Font.c create mode 100644 Firmware/Display_Font.h create mode 100644 Firmware/Display_Image.c create mode 100644 Firmware/Display_Image.h create mode 100644 Firmware/Display_Init.c create mode 100644 Firmware/Display_Init.h create mode 100644 Firmware/Display_Message_Box_Icons.c create mode 100644 Firmware/Display_Message_Box_Icons.h create mode 100644 Firmware/Display_Objects.c create mode 100644 Firmware/Display_Objects.h create mode 100644 Firmware/Display_Objects_Datatypes.h create mode 100644 Firmware/Display_SPI.c create mode 100644 Firmware/Display_SPI.h create mode 100644 Firmware/Display_Shapes.c create mode 100644 Firmware/Display_Shapes.h create mode 100644 Firmware/Display_Touch.c create mode 100644 Firmware/Display_Touch.h create mode 100644 Firmware/Easings.c create mode 100644 Firmware/Easings.h create mode 100644 Firmware/Fonts/Font_DejaVu_Sans_Mono_10x17.c create mode 100644 Firmware/Fonts/Font_DejaVu_Sans_Mono_20x34.c create mode 100644 Firmware/Fonts/Font_DejaVu_Sans_Mono_6x12.c create mode 100644 Firmware/Fonts/Font_DejaVu_Sans_Mono_Bold_15x26.c create mode 100644 Firmware/I2C_Master.c create mode 100644 Firmware/I2C_Master.h create mode 100644 Firmware/INA260.c create mode 100644 Firmware/INA260.h create mode 100644 Firmware/Images/Icons_Settings.xcf create mode 100644 Firmware/Images/Image_Bronze_Copper_Microchip2_64x64.c create mode 100644 Firmware/Images/Image_Computer_64x64.c create mode 100644 Firmware/Images/Image_Energy_64x64.c create mode 100644 Firmware/Images/Image_Fad_Logo_Background_160x160.c create mode 100644 Firmware/Images/Image_Forest_Pine_Midi_64x64.c create mode 100644 Firmware/Images/Image_Midnight_Blue_Back_64x64.c create mode 100644 Firmware/Images/Image_Music_64x64.c create mode 100644 Firmware/Images/Image_Olive_Sage_Diskette_64x64.c create mode 100644 Firmware/Images/Image_Rust_Orange_About1_64x64.c create mode 100644 Firmware/Images/Image_Setting_64x64.c create mode 100644 Firmware/Images/Image_Steel_Blue_Jam_Happy_64x64.c create mode 100644 Firmware/Images/Image_Stone_Blue_Light_On_64x64.c create mode 100644 Firmware/Rotary_Encoder.c create mode 100644 Firmware/Rotary_Encoder.h create mode 100644 Firmware/Screen_Variables.c create mode 100644 Firmware/Screens.h create mode 100644 Firmware/Screens_Display/Screen_Loading.c create mode 100644 Firmware/Screens_Display/Screen_Menu_Main.c create mode 100644 Firmware/Screens_Display/Screen_Select_RGB.c create mode 100644 Firmware/Screens_Display/Screen_Settings.c create mode 100644 Firmware/UI_Control.c create mode 100644 Firmware/UI_Control.h create mode 100644 Firmware/USB_Serial.c create mode 100644 Firmware/USB_Serial.h create mode 100644 Firmware/build/.gitignore create mode 100644 Firmware/build/Pico_Reset_And_Program.py create mode 100644 Firmware/build/build_number.txt create mode 100644 Firmware/build/build_version.txt create mode 100644 Firmware/build/increment_build_number.bat create mode 100644 Firmware/build/pico_program_auto.bat create mode 100644 Firmware/main.c create mode 100644 Firmware/pico_sdk_import.cmake diff --git a/Firmware/.gitignore b/Firmware/.gitignore new file mode 100644 index 0000000..20cbaf6 --- /dev/null +++ b/Firmware/.gitignore @@ -0,0 +1,2 @@ +Version.h +!.vscode/* diff --git a/Firmware/.vscode/c_cpp_properties.json b/Firmware/.vscode/c_cpp_properties.json new file mode 100644 index 0000000..e80461d --- /dev/null +++ b/Firmware/.vscode/c_cpp_properties.json @@ -0,0 +1,22 @@ +{ + "configurations": [ + { + "name": "Pico", + "includePath": [ + "${workspaceFolder}/**", + "${userHome}/.pico-sdk/sdk/2.2.0/**" + ], + "forcedInclude": [ + "${userHome}/.pico-sdk/sdk/2.2.0/src/common/pico_base_headers/include/pico.h", + "${workspaceFolder}/build/generated/pico_base/pico/config_autogen.h" + ], + "defines": [], + "compilerPath": "${userHome}/.pico-sdk/toolchain/14_2_Rel1/bin/arm-none-eabi-gcc.exe", + "compileCommands": "${workspaceFolder}/build/compile_commands.json", + "cStandard": "c17", + "cppStandard": "c++14", + "intelliSenseMode": "linux-gcc-arm" + } + ], + "version": 4 +} diff --git a/Firmware/.vscode/cmake-kits.json b/Firmware/.vscode/cmake-kits.json new file mode 100644 index 0000000..b0f3815 --- /dev/null +++ b/Firmware/.vscode/cmake-kits.json @@ -0,0 +1,15 @@ +[ + { + "name": "Pico", + "compilers": { + "C": "${command:raspberry-pi-pico.getCompilerPath}", + "CXX": "${command:raspberry-pi-pico.getCxxCompilerPath}" + }, + "environmentVariables": { + "PATH": "${command:raspberry-pi-pico.getEnvPath};${env:PATH}" + }, + "cmakeSettings": { + "Python3_EXECUTABLE": "${command:raspberry-pi-pico.getPythonPath}" + } + } +] \ No newline at end of file diff --git a/Firmware/.vscode/extensions.json b/Firmware/.vscode/extensions.json new file mode 100644 index 0000000..a940d7c --- /dev/null +++ b/Firmware/.vscode/extensions.json @@ -0,0 +1,9 @@ +{ + "recommendations": [ + "marus25.cortex-debug", + "ms-vscode.cpptools", + "ms-vscode.cpptools-extension-pack", + "ms-vscode.vscode-serial-monitor", + "raspberry-pi.raspberry-pi-pico" + ] +} \ No newline at end of file diff --git a/Firmware/.vscode/launch.json b/Firmware/.vscode/launch.json new file mode 100644 index 0000000..424aa71 --- /dev/null +++ b/Firmware/.vscode/launch.json @@ -0,0 +1,50 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Pico Debug (Cortex-Debug)", + "cwd": "${userHome}/.pico-sdk/openocd/0.12.0+dev/scripts", + "executable": "${command:raspberry-pi-pico.launchTargetPath}", + "request": "launch", + "type": "cortex-debug", + "servertype": "openocd", + "serverpath": "${userHome}/.pico-sdk/openocd/0.12.0+dev/openocd.exe", + "gdbPath": "${command:raspberry-pi-pico.getGDBPath}", + "device": "${command:raspberry-pi-pico.getChipUppercase}", + "configFiles": [ + "interface/cmsis-dap.cfg", + "target/${command:raspberry-pi-pico.getTarget}.cfg" + ], + "svdFile": "${userHome}/.pico-sdk/sdk/2.2.0/src/${command:raspberry-pi-pico.getChip}/hardware_regs/${command:raspberry-pi-pico.getChipUppercase}.svd", + "runToEntryPoint": "main", + // Fix for no_flash binaries, where monitor reset halt doesn't do what is expected + // Also works fine for flash binaries + "overrideLaunchCommands": [ + "monitor reset init", + "load \"${command:raspberry-pi-pico.launchTargetPath}\"" + ], + "openOCDLaunchCommands": [ + "adapter speed 5000" + ] + }, + { + "name": "Pico Debug (Cortex-Debug with external OpenOCD)", + "cwd": "${workspaceRoot}", + "executable": "${command:raspberry-pi-pico.launchTargetPath}", + "request": "launch", + "type": "cortex-debug", + "servertype": "external", + "gdbTarget": "localhost:3333", + "gdbPath": "${command:raspberry-pi-pico.getGDBPath}", + "device": "${command:raspberry-pi-pico.getChipUppercase}", + "svdFile": "${userHome}/.pico-sdk/sdk/2.2.0/src/${command:raspberry-pi-pico.getChip}/hardware_regs/${command:raspberry-pi-pico.getChipUppercase}.svd", + "runToEntryPoint": "main", + // Fix for no_flash binaries, where monitor reset halt doesn't do what is expected + // Also works fine for flash binaries + "overrideLaunchCommands": [ + "monitor reset init", + "load \"${command:raspberry-pi-pico.launchTargetPath}\"" + ] + }, + ] +} diff --git a/Firmware/.vscode/settings.json b/Firmware/.vscode/settings.json new file mode 100644 index 0000000..cdb8e61 --- /dev/null +++ b/Firmware/.vscode/settings.json @@ -0,0 +1,40 @@ +{ + "cmake.showSystemKits": false, + "cmake.options.statusBarVisibility": "hidden", + "cmake.options.advanced": { + "build": { + "statusBarVisibility": "hidden" + }, + "launch": { + "statusBarVisibility": "hidden" + }, + "debug": { + "statusBarVisibility": "hidden" + } + }, + "cmake.configureOnEdit": false, + "cmake.automaticReconfigure": false, + "cmake.configureOnOpen": false, + "cmake.generator": "Ninja", + "cmake.cmakePath": "${userHome}/.pico-sdk/cmake/v3.31.5/bin/cmake", + "C_Cpp.debugShortcut": false, + "terminal.integrated.env.windows": { + "PICO_SDK_PATH": "${env:USERPROFILE}/.pico-sdk/sdk/2.2.0", + "PICO_TOOLCHAIN_PATH": "${env:USERPROFILE}/.pico-sdk/toolchain/14_2_Rel1", + "Path": "${env:USERPROFILE}/.pico-sdk/toolchain/14_2_Rel1/bin;${env:USERPROFILE}/.pico-sdk/picotool/2.2.0/picotool;${env:USERPROFILE}/.pico-sdk/cmake/v3.31.5/bin;${env:USERPROFILE}/.pico-sdk/ninja/v1.12.1;${env:PATH}" + }, + "terminal.integrated.env.osx": { + "PICO_SDK_PATH": "${env:HOME}/.pico-sdk/sdk/2.2.0", + "PICO_TOOLCHAIN_PATH": "${env:HOME}/.pico-sdk/toolchain/14_2_Rel1", + "PATH": "${env:HOME}/.pico-sdk/toolchain/14_2_Rel1/bin:${env:HOME}/.pico-sdk/picotool/2.2.0/picotool:${env:HOME}/.pico-sdk/cmake/v3.31.5/bin:${env:HOME}/.pico-sdk/ninja/v1.12.1:${env:PATH}" + }, + "terminal.integrated.env.linux": { + "PICO_SDK_PATH": "${env:HOME}/.pico-sdk/sdk/2.2.0", + "PICO_TOOLCHAIN_PATH": "${env:HOME}/.pico-sdk/toolchain/14_2_Rel1", + "PATH": "${env:HOME}/.pico-sdk/toolchain/14_2_Rel1/bin:${env:HOME}/.pico-sdk/picotool/2.2.0/picotool:${env:HOME}/.pico-sdk/cmake/v3.31.5/bin:${env:HOME}/.pico-sdk/ninja/v1.12.1:${env:PATH}" + }, + "raspberry-pi-pico.cmakeAutoConfigure": true, + "raspberry-pi-pico.useCmakeTools": false, + "raspberry-pi-pico.cmakePath": "${HOME}/.pico-sdk/cmake/v3.31.5/bin/cmake", + "raspberry-pi-pico.ninjaPath": "${HOME}/.pico-sdk/ninja/v1.12.1/ninja" +} diff --git a/Firmware/.vscode/tasks.json b/Firmware/.vscode/tasks.json new file mode 100644 index 0000000..9e4b98d --- /dev/null +++ b/Firmware/.vscode/tasks.json @@ -0,0 +1,86 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "Compile Project", + "type": "process", + "isBuildCommand": true, + "command": "${userHome}/.pico-sdk/ninja/v1.12.1/ninja", + "args": [ + "-C", + "${workspaceFolder}/build" + ], + "group": "build", + "presentation": { + "reveal": "always", + "panel": "dedicated" + }, + "problemMatcher": "$gcc", + "windows": { + "command": "${env:USERPROFILE}/.pico-sdk/ninja/v1.12.1/ninja.exe" + } + }, + { + "label": "Run Project", + "type": "process", + "command": "${env:HOME}/.pico-sdk/picotool/2.1.1/picotool/picotool", + "args": [ + "load", + "${command:raspberry-pi-pico.launchTargetPath}", + "-fx" + ], + "presentation": { + "reveal": "always", + "panel": "dedicated" + }, + "problemMatcher": [], + "windows": { + "command": "${env:USERPROFILE}/.pico-sdk/picotool/2.1.1/picotool/picotool.exe" + } + }, + { + "label": "Flash", + "type": "process", + "command": "${userHome}/.pico-sdk/openocd/0.12.0+dev/openocd.exe", + "args": [ + "-s", + "${userHome}/.pico-sdk/openocd/0.12.0+dev/scripts", + "-f", + "interface/cmsis-dap.cfg", + "-f", + "target/${command:raspberry-pi-pico.getTarget}.cfg", + "-c", + "adapter speed 5000; program \"${command:raspberry-pi-pico.launchTargetPath}\" verify reset exit" + ], + "problemMatcher": [], + "windows": { + "command": "${env:USERPROFILE}/.pico-sdk/openocd/0.12.0+dev/openocd.exe" + } + }, + { + "label": "Program Device (Auto-detect)", + "type": "shell", + "command": "pico_program_auto.bat", + "options": { + "cwd": "${workspaceFolder}\\build", + "shell": { + "executable": "cmd.exe", + "args": [ + "/c" + ] + } + }, + "group": { + "kind": "build", + "isDefault": true + }, + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "new" + }, + "problemMatcher": [] + } + ] +} \ No newline at end of file diff --git a/Firmware/CMakeLists.txt b/Firmware/CMakeLists.txt new file mode 100644 index 0000000..ed46778 --- /dev/null +++ b/Firmware/CMakeLists.txt @@ -0,0 +1,114 @@ +# Generated Cmake Pico project file + +cmake_minimum_required(VERSION 3.13) + +set(CMAKE_C_STANDARD 11) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +# Initialise pico_sdk from installed location +# (note this can come from environment, CMake cache etc) + +# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work == +if(WIN32) + set(USERHOME $ENV{USERPROFILE}) +else() + set(USERHOME $ENV{HOME}) +endif() +set(sdkVersion 2.2.0) +set(toolchainVersion 14_2_Rel1) +set(picotoolVersion 2.2.0) +set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake) +if (EXISTS ${picoVscode}) + include(${picoVscode}) +endif() +# ==================================================================================== +set(PICO_BOARD pico2 CACHE STRING "Board type") + +# Pull in Raspberry Pi Pico SDK (must be before project) +include(pico_sdk_import.cmake) + +project(Firmware C CXX ASM) + +# Initialise the Raspberry Pi Pico SDK +pico_sdk_init() + +# Add executable. Default name is the project name, version 0.1 +add_custom_command(OUTPUT Build_Number + # PRE_BUILD + COMMAND cmd /c increment_build_number.bat +) + +add_custom_target(fakeTarget1 ALL + DEPENDS Build_Number +) + +# Add executable. Default name is the project name, version 0.1 + +aux_source_directory(Images/ IMAGE_SOURCES) +include_directories(Images/) + +aux_source_directory(Fonts/ FONT_SOURCES) +include_directories(Fonts/) + +aux_source_directory(Screens_Display/ SCREEN_DISPLAY_SOURCES) +include_directories(Screens_Display/) + +add_executable(Firmware + main.c + USB_Serial.c + Rotary_Encoder.c + Easings.c + UI_Control.c + I2C_Master.c + + Display_Default_Configurations.c + Display_Message_Box_Icons.c + Display_Color.c + Display_Font.c + Display_Image.c + Display_Init.c + Display_Touch.c + Display_Objects.c + Display_Shapes.c + Display_SPI.c + Display.c + + Screen_Variables.c + + ${IMAGE_SOURCES} + ${FONT_SOURCES} + ${SCREEN_DISPLAY_SOURCES} +) + +pico_set_program_name(Firmware "Firmware") +pico_set_program_version(Firmware "0.1") + +# Modify the below lines to enable/disable output over UART/USB +pico_enable_stdio_uart(Firmware 0) +pico_enable_stdio_usb(Firmware 1) + +set_property(TARGET Firmware APPEND_STRING PROPERTY LINK_FLAGS "-Wl,--print-memory-usage") + +# Add the standard library to the build +target_link_libraries(Firmware + pico_stdlib) + +# Add the standard include files to the build +target_include_directories(Firmware PRIVATE + ${CMAKE_CURRENT_LIST_DIR} +) + +# Add any user requested libraries +target_link_libraries(Firmware + hardware_spi + hardware_i2c + hardware_dma + hardware_interp + hardware_timer + hardware_watchdog + hardware_clocks + ) + +pico_add_extra_outputs(Firmware) + diff --git a/Firmware/Display.c b/Firmware/Display.c new file mode 100644 index 0000000..9ba3a44 --- /dev/null +++ b/Firmware/Display.c @@ -0,0 +1,2178 @@ +/* + * Display.c + * + * Created: Sun Mar 21 2021 15:52:12 + * Author Chris + */ +#include "Display.h" + +#include +#include + +#include "hardware/dma.h" + +#include "Screens.h" +#include "Display_SPI.h" +#include "Display_Init.h" +#include "Display_Font.h" +#include "Display_Color.h" +#include "Display_Image.h" +#include "Display_Touch.h" +#include "Display_Shapes.h" +#include "Display_Objects.h" +#include "Display_Message_Box_Icons.h" + +#include "Easings.h" + + +// ============================================================================================ +// Defines +#define DEG2RAD (float)(M_PI / 180) + + +// ============================================================================================ +// Variables +static Display_Image_Buffer _Image_Buffer; +static Display_Image_Buffer _Image_Buffer_Backup; +static Display_Image_Buffer* _Current_Buffer; + +static int _DMA_Channel_Copy_Buffer; +static dma_channel_config _DMA_Config_Copy_Buffer; + +static int _Touched_Button_Return_Value; + +static bool _Object_Selected = false; +static uint _Frame_Counter = 0; +static bool _Touch_Initialized = false; +static bool _Draw_Touch_Reference_Points = false; +static bool _Draw_Center_Lines = false; +static bool _Debug_Print = false; + +static struct Screem_Transition_Settings_t { + Screen_Transition_Direction Direction_Out; + Screen_Transition_Direction Direction_In; + + Coordinates Offset; + Easing Type; + uint32_t Frame_Duration; + + uint32_t Step; + int16_t Position_In; + int16_t Position_Out; +} _Transition_Settings; + +static const int _NONE = 0; +static const int _RIGHT = +1; +static const int _LEFT = -1; +static const int _UP = -1; +static const int _DOWN = +1; + +static int16_t _Menu_Select_Current_Y = 0; +static int16_t _Menu_Icon_Row_Current_X; +static int16_t _Select_YesNo_Current_X = 0; +static int16_t _Select_List_Current_Y = 0; +static float _Entry_Indicator_Current_Angle = 0.0f; +static int16_t _Entry_Indicator_Current_X = 0; + + +// ============================================================================================ +// Function Declarations +void Display_Set_Current_Image_Buffer(Display_Image_Buffer* buffer); + +void Display_Render_Objects_Shape(Coordinates* coordinates_object, Object_Shape* shape); + +void Display_Draw_Style (Coordinates* coordinates, Style* style, uint content_width, uint content_height, bool do_draw); +void Display_Draw_Value_Bar_Rect (Coordinates* coordinates, Object_Value_Bar_Rect* value_bar); +void Display_Draw_Value_Bar_Arc (Coordinates* coordinates, Object_Value_Bar_Arc* value_bar); +void Display_Draw_Graph (Coordinates* coordinates, Object_Graph* graph); +void Display_Draw_Button (Coordinates* coordinates, Object_Button* button); +void Display_Draw_Canvas (Coordinates* coordinates, Object_Canvas* canvas); +void Display_Draw_Message_Box (Coordinates* coordinates, Object_Message_Box* message_box, uint16_t width); +void Display_Draw_Menu_Select (Coordinates* coordinates, char* menu_titles, uint32_t menu_entry_count, uint32_t title_char_length, uint32_t selected_entry, Configuration_Menu_Select* config); +void Display_Draw_Menu_Icon_Row (Coordinates* coordinates, Icon_Row_Item* items, uint32_t item_count, uint32_t selected_item, Configuration_Menu_Icon_Row* config); +void Display_Draw_Menu_Ring (Coordinates* coordinates, Object_Menu_Ring* ring_menu); +void Display_Draw_Menu_Ring_Update_Animation_State(Object_Menu_Ring* menu_ring); +float Display_Draw_Menu_Ring_Get_Item_Angle(Object_Menu_Ring* ring_menu, uint32_t item_index); +void Display_Draw_Menu_Ring_Gradient_Circle(int16_t center_x, int16_t center_y, uint16_t radius, Display_Color color_inner, Display_Color color_outer); +void Display_Draw_Select_YesNo (Coordinates* coordinates, char* title, uint32_t title_length, bool value, Configuration_Select_YesNo* config); +void Display_Draw_Select_List (Coordinates* coordinates, char* list_titles, uint32_t list_entry_count, uint32_t list_char_length, uint32_t selected_entry, Configuration_Select_List* config); +void Display_Draw_Select_Value (Coordinates* coordinates, char* title, uint32_t title_length, int32_t value, int32_t max, int32_t min, char* format, Configuration_Select_Value* config); +void Display_Draw_Select_RGB (Coordinates* coordinates, Object_Select_RGB* rgb_selector); +float Calculate_Progress_Ring_Angle(uint8_t value, uint8_t min_value, uint8_t max_value); +void Display_Draw_Entry_Indicator (Coordinates* coordinates, uint32_t entry_count, int32_t entry_value, Configuration_Entry_Indicator* config); +void Display_Draw_Entry_Indicator_Arc (Coordinates* coordinates, uint32_t entry_count, int32_t entry_value, Configuration_Entry_Indicator* config); +void Display_Draw_Entry_Indicator_Dot (Coordinates* coordinates, uint32_t entry_count, int32_t entry_value, Configuration_Entry_Indicator* config); +void Display_Draw_Focused (Coordinates* coordinates, uint width, uint height); + +Animation_State Display_Animation_Tick(Display_Object* object); + +void Display_Draw_Touch_Refernce_Points(Display_Color color); +void Display_Draw_Touch_Marker(Display_Color color); +void Display_Draw_Center_Lines(Display_Color color); + +void Display_Check_Button_Touch(int16_t x, int16_t y); +void Display_Object_Select_Next(void); +void Display_Object_Select_Previous(void); +Display_Object* Display_Get_Selected_Object(void); +int Display_Get_Index_Of_Object(Display_Object* object); + +void Display_Screen_Transition_Tick(); +void Display_Buffer_Shift_Left(uint32_t steps); +void Display_Buffer_Shift_Right(uint32_t steps); +void Display_Buffer_Shift_Up(uint32_t steps); +void Display_Buffer_Shift_Down(uint32_t steps); + +void Display_Copy_Buffer(Display_Image_Buffer *src, Display_Image_Buffer *dest); + + +/******************************************************************* + Functions +*******************************************************************/ +void Display_Init(Display_Color initial_color, bool send_buffer, bool init_touch) +{ + _Touch_Initialized = init_touch; + + _Touched_Button_Return_Value = -1; + + Display_Set_Current_Image_Buffer(&_Image_Buffer); + + + _Transition_Settings.Direction_Out = TRANSITION_NONE; + _Transition_Settings.Direction_In = TRANSITION_NONE; + _Transition_Settings.Offset.X = 0; + _Transition_Settings.Offset.Y = 0; + _Transition_Settings.Type = LINEAR; + _Transition_Settings.Frame_Duration = 0; + _Transition_Settings.Step = 0; + _Transition_Settings.Position_In = 0; + _Transition_Settings.Position_Out = 0; + + + _DMA_Channel_Copy_Buffer = dma_claim_unused_channel(true); + _DMA_Config_Copy_Buffer = dma_channel_get_default_config(_DMA_Channel_Copy_Buffer); + channel_config_set_transfer_data_size(&_DMA_Config_Copy_Buffer, DMA_SIZE_32); + channel_config_set_read_increment(&_DMA_Config_Copy_Buffer, true); + channel_config_set_write_increment(&_DMA_Config_Copy_Buffer, true); + + + Display_Shapes_Init(&_Current_Buffer); + Display_Font_Init(); + Display_Image_Init(&_Current_Buffer, initial_color); + + Display_Init_GPIOs(); + Display_SPI_Init(init_touch); + + Display_Init_Reset(); + Display_Init_Registers(); + Display_Init_WakeUp(); + + if(init_touch) { + Display_Touch_Init(); + } + + Display_Objects_Init(initial_color); + + if(send_buffer) { + Display_Render_Objects(); + } +} + +void Display_Issue_Touch_Event(int16_t x_screen, int16_t y_screen) +{ + // Display_Check_Button_Touch(x_screen, y_screen); + _Screen_Touch_Event(x_screen, y_screen); +} + +void Display_Set_Draw_Touch_Reference_Points(bool do_draw) +{ + _Draw_Touch_Reference_Points = do_draw; +} + +void Display_Set_Draw_Center_Lines(bool do_draw) +{ + _Draw_Center_Lines = do_draw; +} + +void Display_Screen_Transition_Start(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration) +{ + _Transition_Settings.Direction_Out = direction_out; + _Transition_Settings.Direction_In = TRANSITION_NONE; + _Transition_Settings.Offset.X = 0; + _Transition_Settings.Offset.Y = 0; + _Transition_Settings.Type = type; + _Transition_Settings.Frame_Duration = frame_duration; + _Transition_Settings.Step = 0; + _Transition_Settings.Position_In = 0; + _Transition_Settings.Position_Out = 0; + + if(_Transition_Settings.Frame_Duration == 0) { + return; + } + + switch (direction_in) + { + case TRANSITION_NONE: + break; + + case TRANSITION_LEFT: + _Transition_Settings.Offset.X = +DISPLAY_WIDTH; + _Transition_Settings.Direction_In = direction_in; + break; + + case TRANSITION_RIGHT: + _Transition_Settings.Offset.X = -DISPLAY_WIDTH; + _Transition_Settings.Direction_In = direction_in; + break; + + case TRANSITION_UP: + _Transition_Settings.Offset.Y = +DISPLAY_HEIGHT; + _Transition_Settings.Direction_In = direction_in; + break; + + case TRANSITION_DOWN: + _Transition_Settings.Offset.Y = -DISPLAY_HEIGHT; + _Transition_Settings.Direction_In = direction_in; + break; + + default: + break; + } + + if(_Transition_Settings.Direction_Out != TRANSITION_NONE) { + Display_Copy_Buffer(&_Image_Buffer, &_Image_Buffer_Backup); + } +} + +void Display_Screen_Transition_Tick() +{ + if(_Transition_Settings.Direction_Out == TRANSITION_NONE && _Transition_Settings.Direction_In == TRANSITION_NONE) { + return; + } + + float Transition_X = ((float)_Transition_Settings.Step) / ((float)_Transition_Settings.Frame_Duration); + float New_Percent = 0.0f; + + New_Percent = ApplyEasing1(Transition_X, _Transition_Settings.Type); + + // Calculate position targets separately for incoming and outgoing directions + int16_t Position_Target_In = 0; + int16_t Position_Target_Out = 0; + + // Set position target for incoming screen (only if there is an incoming transition) + if (_Transition_Settings.Direction_In != TRANSITION_NONE) + { + switch (_Transition_Settings.Direction_In) + { + case TRANSITION_LEFT: + case TRANSITION_RIGHT: + Position_Target_In = DISPLAY_WIDTH; + break; + + case TRANSITION_UP: + case TRANSITION_DOWN: + Position_Target_In = DISPLAY_HEIGHT; + break; + + default: + _Transition_Settings.Offset.X = 0; + _Transition_Settings.Offset.Y = 0; + _Transition_Settings.Direction_In = TRANSITION_NONE; + return; + } + } + + // Set position target for outgoing screen (only if there is an outgoing transition) + if (_Transition_Settings.Direction_Out != TRANSITION_NONE) + { + switch (_Transition_Settings.Direction_Out) + { + case TRANSITION_LEFT: + case TRANSITION_RIGHT: + Position_Target_Out = DISPLAY_WIDTH; + break; + + case TRANSITION_UP: + case TRANSITION_DOWN: + Position_Target_Out = DISPLAY_HEIGHT; + break; + + case TRANSITION_NONE: + Position_Target_Out = 0; // No outgoing transition + break; + + default: + Position_Target_Out = 0; + break; + } + } + + // Calculate new positions and shift steps + int16_t New_Position_In = 0; + int16_t Shift_Step_In = 0; + + // Only calculate incoming position if there's an incoming transition + if (_Transition_Settings.Direction_In != TRANSITION_NONE) { + New_Position_In = (uint)(New_Percent * Position_Target_In); + Shift_Step_In = New_Position_In - _Transition_Settings.Position_In; + } + + // Handle incoming screen movement + if (_Transition_Settings.Direction_In != TRANSITION_NONE) + { + switch (_Transition_Settings.Direction_In) + { + case TRANSITION_LEFT: _Transition_Settings.Offset.X -= Shift_Step_In; break; + case TRANSITION_RIGHT: _Transition_Settings.Offset.X += Shift_Step_In; break; + case TRANSITION_UP: _Transition_Settings.Offset.Y -= Shift_Step_In; break; + case TRANSITION_DOWN: _Transition_Settings.Offset.Y += Shift_Step_In; break; + } + + _Transition_Settings.Position_In += Shift_Step_In; + } + + + + int16_t New_Position_Out = 0; + int16_t Shift_Step_Out = 0; + + // Only calculate outgoing position if there's an outgoing transition + if (_Transition_Settings.Direction_Out != TRANSITION_NONE) { + New_Position_Out = (uint)(New_Percent * Position_Target_Out); + Shift_Step_Out = New_Position_Out - _Transition_Settings.Position_Out; + } + + // Handle outgoing screen movement (if there is one) + if (_Transition_Settings.Direction_Out != TRANSITION_NONE) + { + Display_Set_Current_Image_Buffer(&_Image_Buffer_Backup); + switch (_Transition_Settings.Direction_Out) + { + case TRANSITION_LEFT: Display_Buffer_Shift_Left(Shift_Step_Out); break; + case TRANSITION_RIGHT: Display_Buffer_Shift_Right(Shift_Step_Out); break; + case TRANSITION_UP: Display_Buffer_Shift_Up(Shift_Step_Out); break; + case TRANSITION_DOWN: Display_Buffer_Shift_Down(Shift_Step_Out); break; + } + Display_Set_Current_Image_Buffer(&_Image_Buffer); + + _Transition_Settings.Position_Out += Shift_Step_Out; + } + + // Update step counter and position + if (_Transition_Settings.Step < _Transition_Settings.Frame_Duration) + { + _Transition_Settings.Step++; + } + else + { + _Transition_Settings.Offset.X = 0; + _Transition_Settings.Offset.Y = 0; + _Transition_Settings.Direction_In = TRANSITION_NONE; + + _Transition_Settings.Direction_Out = TRANSITION_NONE; + } +} + +void Display_Render_Objects(void) +{ + Object_Float* F; + Object_Integer* I; + Object_Text* T; + Object_Value_Bar_Rect* VR; + Object_Value_Bar_Arc* VA; + Object_Graph* G; + Object_Button* N; + Object_Image_Color* IM; + Object_Bool* B; + Object_Shape* S; + Object_Canvas* C; + Object_Message_Box* M; + Object_Menu_Select* MS; + Object_Menu_Icon_Row* MI; + Object_Menu_Ring* MR; + Object_Select_YesNo* YN; + Object_Select_List* SL; + Object_Select_Value* SV; + Object_Select_RGB* SR; + Object_Entry_Indicator* EI; + char String[64]; + uint String_Char_Count, Width; + Display_Color Color; + + Animation_State Animation_State = COMPLETE; + + if(_Transition_Settings.Direction_Out != TRANSITION_NONE) { + Display_Copy_Buffer(&_Image_Buffer_Backup, &_Image_Buffer); + } + else { + Display_Shapes_Fill_Screen(Display_Objects_Background_Color_Get()); + } + + for(uint i=0;iStyle; + Animation* Animation = Object->Animation; + + if(Animation != NULL) { + if(Animation->Animation_Start == START_AFTER_PREVIOUS && Animation_State != COMPLETE) { + continue; + } + + Animation_State = Display_Animation_Tick(Object); + + if(Animation_State == NO_STARTED || Animation_State == DELAYING) { + continue; + } + } + + if(Object->Enabled == false) { + continue; + } + + Coordinates Coordinates_Object = Object->Coordinates; + Coordinates_Object.X += Object->Content_Offset.X; + Coordinates_Object.Y += Object->Content_Offset.Y; + + Coordinates_Object.X += _Transition_Settings.Offset.X; + Coordinates_Object.Y += _Transition_Settings.Offset.Y; + + if(Style != NULL) { + bool Do_Draw_Style = true; + + if(Object->Type == MESSAGE_BOX) + { + M = (Object_Message_Box*)(Object->Data); + if(M->Show_Ticks_Left == 0) { + Do_Draw_Style = false; + } + } + + Coordinates Coordinates_Style = Object->Coordinates; + Coordinates_Style.X += _Transition_Settings.Offset.X; + Coordinates_Style.Y += _Transition_Settings.Offset.Y; + Display_Draw_Style(&Coordinates_Style, Style, Object->Dimension.Width, Object->Dimension.Height, Do_Draw_Style); + } + + if(Object->Focused == true) { + Coordinates Coordinates_Focus = Object->Coordinates; + Coordinates_Focus.X += _Transition_Settings.Offset.X; + Coordinates_Focus.Y += _Transition_Settings.Offset.Y; + + Display_Draw_Focused(&Coordinates_Focus, Object->Dimension.Width, Object->Dimension.Height); + } + + switch (Object->Type) + { + case FLOAT: + F = (Object_Float*)Object->Data; + Display_Font_Set_Font(F->Font->Font); + String_Char_Count = sprintf(String, F->Format, *(F->Value)); + + Display_Font_Print_String(Coordinates_Object.X, Coordinates_Object.Y, String, String_Char_Count, F->Font->Character_Spacing, F->Color); + break; + + case INTEGER: + I = (Object_Integer*)Object->Data; + Display_Font_Set_Font(I->Font->Font); + String_Char_Count = sprintf(String, I->Format, *(I->Value)); + + Display_Font_Print_String(Coordinates_Object.X, Coordinates_Object.Y, String, String_Char_Count, I->Font->Character_Spacing, I->Color); + break; + + case TEXT: + T = (Object_Text*)Object->Data; + Display_Font_Set_Font(T->Font->Font); + sprintf(String, "%s", T->Text); + String_Char_Count = T->Length; + + Display_Font_Print_String(Coordinates_Object.X, Coordinates_Object.Y, String, String_Char_Count, T->Font->Character_Spacing, T->Color); + break; + + case VALUE_BAR_RECT: + VR = (Object_Value_Bar_Rect*)Object->Data; + Display_Draw_Value_Bar_Rect(&Coordinates_Object, VR); + break; + + case VALUE_BAR_ARC: + VA = (Object_Value_Bar_Arc*)Object->Data; + Display_Draw_Value_Bar_Arc(&Coordinates_Object, VA); + break; + + case GRAPH: + G = (Object_Graph*)Object->Data; + Display_Draw_Graph(&Coordinates_Object, G); + break; + + case BUTTON: + N = (Object_Button*)Object->Data; + Display_Draw_Button(&Coordinates_Object, N); + break; + + case IMAGE: + IM = (Object_Image_Color*)Object->Data; + if(IM->Rotation_Angle == 0) { + Display_Image_Draw_Color_Alpha(Coordinates_Object.X, Coordinates_Object.Y, IM->Image, IM->Alpha); + } + else { + Display_Image_Draw_Color_Rotated_Alpha(Coordinates_Object.X, Coordinates_Object.Y, IM->Image, IM->Rotation_Angle, IM->Alpha); + } + break; + + case BOOLEAN: + B = (Object_Bool*)Object->Data; + Display_Font_Set_Font(B->Font->Font); + + if(*B->Value == true) + { + sprintf(String, "%s", B->Text_True); + String_Char_Count = B->Length_True; + Color = B->Color_True; + } + else + { + sprintf(String, "%s", B->Text_False); + String_Char_Count = B->Length_False; + Color = B->Color_False; + } + + Display_Font_Print_String(Coordinates_Object.X, Coordinates_Object.Y, String, String_Char_Count, B->Font->Character_Spacing, Color); + break; + + case SHAPE: + S = (Object_Shape*)Object->Data; + Display_Render_Objects_Shape(&Coordinates_Object, S); + break; + + case CANVAS: + C = (Object_Canvas*)(Object->Data); + Display_Draw_Canvas(&Coordinates_Object, C); + break; + + case MESSAGE_BOX: + M = (Object_Message_Box*)(Object->Data); + + Width = Object->Dimension.Width; + if(Style != NULL) { + Width -= ((Style->Border_Thickness << 1) + Style->Padding[PADDING_LEFT] + Style->Padding[PADDING_RIGHT]); + } + + Display_Draw_Message_Box(&Coordinates_Object, M, Width); + break; + + case MENU_SELECT: + MS = (Object_Menu_Select*)(Object->Data); + Display_Draw_Menu_Select(&Coordinates_Object, MS->Menu_Titles, MS->Menu_Entry_Count, MS->Title_Char_Length, *MS->Selected_Entry, MS->Config); + break; + + case MENU_ICON_ROW: + MI = (Object_Menu_Icon_Row*)(Object->Data); + Display_Draw_Menu_Icon_Row(&Coordinates_Object, MI->Items, MI->Item_Count, *MI->Selected_Item, MI->Config); + break; + + case MENU_RING: + MR = (Object_Menu_Ring*)(Object->Data); + Display_Draw_Menu_Ring(&Coordinates_Object, MR); + break; + + case SELECT_YESNO: + YN = (Object_Select_YesNo*)(Object->Data); + Display_Draw_Select_YesNo(&Coordinates_Object, YN->Title, YN->Title_Length, *YN->Value, YN->Config); + break; + + case SELECT_LIST: + SL = (Object_Select_List*)(Object->Data); + Display_Draw_Select_List(&Coordinates_Object, SL->List_Titles, SL->List_Entry_Count, SL->List_Char_Length, *SL->Selected_Entry, SL->Config); + break; + + case SELECT_VALUE: + SV = (Object_Select_Value*)(Object->Data); + Display_Draw_Select_Value(&Coordinates_Object, SV->Title, SV->Title_Length, *SV->Value, SV->Max, SV->Min, SV->Format, SV->Config); + break; + + case SELECT_RGB: + SR = (Object_Select_RGB*)(Object->Data); + Display_Draw_Select_RGB(&Coordinates_Object, SR); + break; + + case ENTRY_INDICATOR: + EI = (Object_Entry_Indicator*)(Object->Data); + Display_Draw_Entry_Indicator(&Coordinates_Object, EI->Entry_Count, *EI->Entry_Value, EI->Config); + break; + + default: + break; + } + } + + if(_Draw_Touch_Reference_Points) { + Display_Draw_Touch_Refernce_Points(DISPLAY_COLOR_GREEN); + } + + if(_Draw_Center_Lines) { + Display_Draw_Center_Lines(DISPLAY_COLOR_GREENYELLOW); + } + + Display_Draw_Touch_Marker(DISPLAY_COLOR_BLUE); +} + +void Display_Send_Buffer(void) +{ + Display_SPI_Start_Command(DISPLAY_MEMORY_WRITE); + Display_SPI_Send_Data((uint8_t *)_Image_Buffer.Dim_1, DISPLAY_IMAGE_BUFFER_BYTE_SIZE, true); +} + +bool Display_Send_Buffer_Completed(void) +{ + return Display_SPI_DMA_Transfer_Completed(); +} + +void Display_Show_Test_Screen(void) +{ + int16_t Width = DISPLAY_WIDTH / 5; + + Display_Shapes_Draw_Rect_Filled(0*Width, 0, Width, DISPLAY_HEIGHT, DISPLAY_COLOR_RED); + Display_Shapes_Draw_Rect_Filled(1*Width, 0, Width, DISPLAY_HEIGHT, DISPLAY_COLOR_GREEN); + Display_Shapes_Draw_Rect_Filled(2*Width, 0, Width, DISPLAY_HEIGHT, DISPLAY_COLOR_BLUE); + Display_Shapes_Draw_Rect_Filled(3*Width, 0, Width, DISPLAY_HEIGHT, DISPLAY_COLOR_BLACK); + Display_Shapes_Draw_Rect_Filled(4*Width, 0, Width, DISPLAY_HEIGHT, DISPLAY_COLOR_WHITE); +} + +int Display_Get_Button_Touch_Return_Value(void) +{ + int Return_Value = _Touched_Button_Return_Value; + + _Touched_Button_Return_Value = -1; + + return Return_Value; +} + +void Display_Select_First_Object(void) +{ + Display_Action_CW(); +} + +void Display_Action_CW(void) +{ + if(_Object_Selected == false) + { + (*_Screen_On_Objects_Defocused)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + Display_Object_Select_Next(); + (*_Screen_On_Objects_Focused)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + } + else + { + (*_Screen_Action_CW)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + } +} + +void Display_Action_CCW(void) +{ + if(_Object_Selected == false) + { + (*_Screen_On_Objects_Defocused)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + Display_Object_Select_Previous(); + (*_Screen_On_Objects_Focused)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + } + else + { + (*_Screen_Action_CCW)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + } +} + +void Display_Action_SW(void) +{ + if(_Object_Selected == false) + { + _Object_Selected = true; + (*_Screen_On_Object_Select)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + } + else + { + _Object_Selected = false; + (*_Screen_On_Object_Deselect)(Display_Get_Index_Of_Object(Display_Get_Selected_Object())); + } +} + +void Display_Select_Object(void) +{ + _Object_Selected = true; +} + +void Display_Unselect_Object(void) +{ + _Object_Selected = false; +} + +void Display_Menu_Icon_Row_Set(uint32_t initially_selected_item, uint32_t icon_space_width) +{ + _Menu_Icon_Row_Current_X = (DISPLAY_WIDTH >> 1) - initially_selected_item * icon_space_width; +} + +void Display_Inc_Frame_Counter(void) +{ + _Frame_Counter++; +} + +uint* Display_Get_Frame_Counter_Reference(void) +{ + return &_Frame_Counter; +} + +void Display_Set_Debug_Print(void) +{ + _Debug_Print = true; +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ +void Display_Set_Current_Image_Buffer(Display_Image_Buffer* buffer) +{ + if(buffer != NULL) { + _Current_Buffer = buffer; + } +} + +void Display_Render_Objects_Shape(Coordinates* coordinates_object, Object_Shape* shape) +{ + int16_t X1, X2, Y1, Y2; + + switch (shape->Type) + { + case RECTANGLE_FILLED: + Display_Shapes_Draw_Rect_Filled(coordinates_object->X, coordinates_object->Y, shape->Dimension.Width, shape->Dimension.Height, shape->Color); + break; + + case RECTANGLE_FRAME: + Display_Shapes_Draw_Rect_Frame(coordinates_object->X, coordinates_object->Y, shape->Dimension.Width, shape->Dimension.Height, shape->Thickness, shape->Color); + break; + + case ROUNDED_RECTANGLE_FILLED: + Display_Shapes_Draw_Round_Rect_Filled(coordinates_object->X, coordinates_object->Y, shape->Dimension.Width, shape->Dimension.Height, shape->Radius_Start, shape->Color); + break; + + case ROUNDED_RECTANGLE_FRAME: + Display_Shapes_Draw_Round_Rect_Frame(coordinates_object->X, coordinates_object->Y, shape->Dimension.Width, shape->Dimension.Height, shape->Radius_Start, shape->Thickness, shape->Color); + break; + + case CIRCLE: + Display_Shapes_Draw_Circle_Frame(coordinates_object->X, coordinates_object->Y, shape->Radius_Start, shape->Thickness, shape->Color); + break; + + case ARC: + Display_Shapes_Draw_Arc_Frame(coordinates_object->X, coordinates_object->Y, shape->Radius_Start, shape->Thickness, shape->Angle_Start, shape->Angle_End, shape->Draw_Steps, shape->Color); + break; + + case LINE_XY: + X2 = shape->Angle_Start - _Transition_Settings.Offset.X; // Angle Start contains X2 + Y2 = shape->Angle_End - _Transition_Settings.Offset.Y; // Angle End contains Y2 + Display_Shapes_Draw_Line_XY(coordinates_object->X, coordinates_object->Y, X1, Y2, shape->Thickness, shape->Color); + break; + + case LINE_RAD: + Display_Shapes_Draw_Line_Rad(coordinates_object->X, coordinates_object->Y, shape->Angle_Start, shape->Radius_Start, shape->Radius_End, shape->Thickness, shape->Color); + break; + } +} + +void Display_Draw_Style(Coordinates* coordinates, Style* style, uint content_width, uint content_height, bool do_draw) +{ + /* + INFO (2021-11-11): + Width and Height information from the Style-Struct is currently not used. The dimension is stored in the Object + itself and does not change during runtime. A width or height adapted to the contect size is currently not available. + It is also not possible to align the content within the style. This has to be done by setting the Padding values + properly. + I am not sure if the above mentioned functionality is needed or will be used by at all. This is why I will not + implement these functions and keep things simple until I see I really need it. + */ + + uint16_t Height = content_height; + uint16_t Width = content_width; + Display_Color Border_Color = style->Border_Color; + uint16_t Border_Thickness = style->Border_Thickness; + uint16_t Border_Radius = style->Border_Radius; + + if(!do_draw) { + return; + } + + if(style->Background_Color != Display_Objects_Background_Color_Get()) { + if(Border_Radius > 0) { + Display_Shapes_Draw_Round_Rect_Filled(coordinates->X + Border_Thickness, coordinates->Y + Border_Thickness, Width - 2 * Border_Thickness, Height - 2 * Border_Thickness, Border_Radius, style->Background_Color); + } else { + Display_Shapes_Draw_Rect_Filled(coordinates->X + Border_Thickness, coordinates->Y + Border_Thickness, Width - 2 * Border_Thickness, Height - 2 * Border_Thickness, style->Background_Color); + } + } + + if(style->Border_Color != Display_Objects_Background_Color_Get() && style->Border_Thickness > 0) { + Display_Shapes_Draw_Round_Rect_Frame(coordinates->X, coordinates->Y, Width, Height, Border_Radius, Border_Thickness, Border_Color); + } +} + +void Display_Draw_Value_Bar_Rect(Coordinates* coordinates, Object_Value_Bar_Rect* value_bar) +{ + Object_Value_Bar_Rect* V = value_bar; + + if(*V->Value >= V->Max) + { + Display_Shapes_Draw_Rect_Filled(coordinates->X, coordinates->Y, V->Dimension.Width, V->Dimension.Height, V->Color); + return; + } + + if(*V->Value < V->Min) + { + return; + } + + float Positive_Factor = ((float)(*V->Value - V->Min)) / ((float)(V->Max - V->Min)); + + uint16_t Target_Value = V->Dimension.Width; + if(V->Orientation == BOTTOM_TO_TOP || V->Orientation == TOP_TO_BOTTOM) + { + Target_Value = V->Dimension.Height; + } + + uint16_t Positive_Part = Target_Value * Positive_Factor; + uint16_t Negative_Part = Target_Value - Positive_Part; + + switch (V->Orientation) + { + case LEFT_TO_RIGHT: + Display_Shapes_Draw_Rect_Filled(coordinates->X, coordinates->Y, Positive_Part, V->Dimension.Height, V->Color); + break; + + case RIGHT_TO_LEFT: + Display_Shapes_Draw_Rect_Filled(coordinates->X + Negative_Part, coordinates->Y, Positive_Part, V->Dimension.Height, V->Color); + break; + + case BOTTOM_TO_TOP: + Display_Shapes_Draw_Rect_Filled(coordinates->X, coordinates->Y + Negative_Part, V->Dimension.Width, Positive_Part, V->Color); + break; + + case TOP_TO_BOTTOM: + Display_Shapes_Draw_Rect_Filled(coordinates->X, coordinates->Y, V->Dimension.Width, Positive_Part, V->Color); + break; + } +} + +void Display_Draw_Value_Bar_Arc(Coordinates* coordinates, Object_Value_Bar_Arc* value_bar) +{ + Object_Value_Bar_Arc* V = value_bar; + + if(*V->Value != V->Current) + { + // Need to drcrease + if(*V->Value < V->Current) + { + if(abs(*V->Value - V->Current) <= V->Delta_Dec) { + V->Current = *V->Value; + } + else { + V->Current -= V->Delta_Dec; + } + } + // Need to increase + else + { + if(abs(*V->Value - V->Current) <= V->Delta_Inc) { + V->Current = *V->Value; + } + else { + V->Current += V->Delta_Inc; + } + } + } + + Coordinates Coordinates_Start = Display_Shapes_Polar_To_XY(coordinates->X, coordinates->Y, V->Arc->Angle_Start, V->Arc->Radius_Start); + Display_Shapes_Draw_Circle_Filled(Coordinates_Start.X, Coordinates_Start.Y, V->Arc->Thickness >> 1, V->Arc->Color); + + Coordinates Coordinates_End = Display_Shapes_Polar_To_XY(coordinates->X, coordinates->Y, V->Angle_End, V->Arc->Radius_Start); + Display_Shapes_Draw_Circle_Filled(Coordinates_End.X, Coordinates_End.Y, V->Arc->Thickness >> 1, V->Arc->Color); + + if(V->Current >= V->Max) + { + V->Arc->Angle_End = V->Angle_End; + } + else if(V->Current <= V->Min) + { + return; + } + else + { + float Value_Ratio = (float)(V->Current - V->Min) / (float)(V->Max - V->Min); + V->Arc->Angle_End = V->Arc->Angle_Start + (int16_t)(Value_Ratio * (V->Angle_End - V->Arc->Angle_Start)); + } + + Display_Shapes_Draw_Arc_Frame(coordinates->X, coordinates->Y, V->Arc->Radius_Start, V->Arc->Thickness, V->Arc->Angle_Start, V->Arc->Angle_End, V->Arc->Draw_Steps, V->Arc->Color); +} + +void Display_Draw_Graph(Coordinates* coordinates, Object_Graph* graph) +{ + uint16_t Value; + uint16_t Y; + + for(int i=0;iData_Length;i++) + { + Value = graph->Data[i]; + + if(Value < graph->Min) { + Value = graph->Min; + } + + if(Value > graph->Max) { + Value = graph->Max; + } + + Y = (graph->Dimension.Height * (Value - graph->Min)) / (graph->Max - graph->Min); + Y = graph->Dimension.Height - Y; + + Display_Shapes_Draw_Pixel_Safe(coordinates->X + i, coordinates->Y + Y, graph->Color); + } +} + +void Display_Draw_Button(Coordinates* coordinates, Object_Button* button) +{ + int16_t X = coordinates->X; + int16_t Y = coordinates->Y; + + Display_Shapes_Draw_HLine(X, Y , button->Dimension.Width - 1, 1, DISPLAY_COLOR_WHITE); + Display_Shapes_Draw_VLine(X, Y+1 , button->Dimension.Height - 2, 1, DISPLAY_COLOR_WHITE); + + Display_Shapes_Draw_HLine(X+1, Y+1 , button->Dimension.Width - 3, 1, DISPLAY_COLOR_FROM_RGB888(216, 216, 216)); + Display_Shapes_Draw_VLine(X+1, Y+2 , button->Dimension.Height - 4, 1, DISPLAY_COLOR_FROM_RGB888(216, 216, 216)); + + if(DISPLAY_COLOR_FROM_RGB888(184, 184, 184) != Display_Objects_Background_Color_Get()) { + Display_Shapes_Draw_Rect_Filled(X+2, Y+2, button->Dimension.Width - 4, button->Dimension.Height - 4, DISPLAY_COLOR_FROM_RGB888(184, 184, 184)); + } + + Display_Font_Set_Font(button->Font->Font); + uint16_t Text_Width = Display_Font_Width_String(button->Text, button->Length, 2); + uint16_t Text_Height = Display_Font_Get_Font_Height(); + int16_t Text_X = X + (button->Dimension.Width - Text_Width) / 2; + int16_t Text_Y = Y + (button->Dimension.Height - Text_Height) / 2; + Display_Font_Print_String(Text_X, Text_Y, button->Text, button->Length, button->Font->Character_Spacing, button->Color); + + Display_Shapes_Draw_HLine(X+1, Y+button->Dimension.Height-2, button->Dimension.Width - 2, 1, DISPLAY_COLOR_FROM_RGB888(120, 120, 120)); + Display_Shapes_Draw_VLine(X+button->Dimension.Width-2, Y+1 , button->Dimension.Height - 3, 1, DISPLAY_COLOR_FROM_RGB888(120, 120, 120)); + + Display_Shapes_Draw_HLine(X, Y+button->Dimension.Height-1, button->Dimension.Width , 1, DISPLAY_COLOR_BLACK); + Display_Shapes_Draw_VLine(X+button->Dimension.Width-1, Y, button->Dimension.Height - 1 , 1, DISPLAY_COLOR_BLACK); +} + +void Display_Draw_Canvas(Coordinates* coordinates, Object_Canvas* canvas) +{ + int16_t X = coordinates->X; + int16_t Y = coordinates->Y; + + for(uint y=0;yDimension.Height;y++) + { + for(uint x=0;xDimension.Width;x++) + { + Display_Shapes_Draw_Pixel_Safe(X+x, Y+y, canvas->Data[y * canvas->Dimension.Width + x]); + } + } +} + +void Display_Draw_Message_Box(Coordinates* coordinates, Object_Message_Box* message_box, uint16_t width) +{ + Object_Message_Box* M = message_box; + char String[64]; + + if(M->Show_Ticks_Left > 0) + { + Display_Font_Set_Font(M->Font->Font); + sprintf(String, "%s", M->Text); + int String_Char_Count = M->Length; + + Coordinates Coordinates_Offset_Text = { 0, 0 }; + Coordinates Coordinates_Offset_Bar = { 0, 0 }; + Coordinates_Offset_Bar.Y = MESSAGE_BOX_TEXT_BAR_DISTANCE + Display_Font_Get_Font_Height(); + + if(M->Icon != MESSAGE_BOX_ICON_NONE) { + Coordinates_Offset_Text.X = MESSAGE_BOX_TEXT_ICON_DISTANCE + Display_Message_Box_Icons_Get_Icon_Width(M->Icon); + Display_Image_Draw_Alpha(coordinates->X, coordinates->Y, Display_Message_Box_Icons_Get_Icon_Ptr(M->Icon), M->Color); + + if(Display_Message_Box_Icons_Get_Icon_Height(M->Icon) > Display_Font_Get_Font_Height()) { + Coordinates_Offset_Text.Y = (Display_Message_Box_Icons_Get_Icon_Height(M->Icon) - Display_Font_Get_Font_Height()) >> 1; + Coordinates_Offset_Bar.Y = MESSAGE_BOX_TEXT_BAR_DISTANCE + Display_Message_Box_Icons_Get_Icon_Height(M->Icon); + } + } + + Display_Font_Print_String(coordinates->X + Coordinates_Offset_Text.X, coordinates->Y + Coordinates_Offset_Text.Y, String, String_Char_Count, M->Font->Character_Spacing, M->Color); + + uint16_t Bar_Width = (width * M->Show_Ticks_Left) / M->Show_Ticks_Max; + Display_Shapes_Draw_Rect_Filled(coordinates->X + width - Bar_Width, coordinates->Y + Coordinates_Offset_Bar.Y, Bar_Width, MESSAGE_BOX_BAR_HEIGHT, M->Color); + + M->Show_Ticks_Left--; + } +} + +void Display_Draw_Menu_Select(Coordinates* coordinates, char* menu_titles, uint32_t menu_entry_count, uint32_t title_char_length, uint32_t selected_entry, Configuration_Menu_Select* config) +{ + Display_Font_Set_Font(config->Font[0]); + + const int16_t X_Offset = coordinates->X + config->X_Offset; + const int16_t X_Gap = config->X_Indent; + + const int16_t Y_Offset = coordinates->Y + DISPLAY_Y_CENTER - (Display_Font_Get_Font_Height() >> 1); + const int16_t Y_Gap = Display_Font_Get_Font_Height() + 2; + + const int16_t Arrow_Width = Display_Font_Width_String("->", 2, DISPLAY_DEFAULT_CHAR_SPACING) + 4; + Display_Font_Print_String(X_Offset - Arrow_Width, Y_Offset, "->", 2, DISPLAY_DEFAULT_CHAR_SPACING, DISPLAY_COLOR_WHITE); + + int16_t Y_Target = (-1) * selected_entry * Y_Gap; + + int Move_Direction = _NONE; + if(Y_Target > _Menu_Select_Current_Y) { + Move_Direction = _DOWN; + } else if(Y_Target < _Menu_Select_Current_Y) { + Move_Direction = _UP; + } + + int16_t Distance = abs(Y_Target - _Menu_Select_Current_Y); + _Menu_Select_Current_Y += (((Distance >> 1) + 1) * Move_Direction); + + for(int i=0;i menu_entry_count) { Max = menu_entry_count; } + + if(selected_entry>=Min && selected_entry<=Max) + { + int16_t Y_Coord = _Menu_Select_Current_Y + Y_Gap*i; + int16_t X_Coord = (abs(Y_Coord) * X_Gap) / Y_Gap; + + Display_Font_Set_Font(config->Font[abs(selected_entry - i)]); + + int16_t Y_Gap_Center_Font = (((Y_Gap-2) - Display_Font_Get_Font_Height()) + 2) >> 1; + + Display_Font_Print_String(X_Offset - X_Coord, Y_Offset + Y_Coord + Y_Gap_Center_Font, menu_titles + i*title_char_length, title_char_length, DISPLAY_DEFAULT_CHAR_SPACING, config->Color[abs(selected_entry - i)]); + } + } +} + +void Display_Draw_Menu_Icon_Row(Coordinates* coordinates, Icon_Row_Item* items, uint32_t item_count, uint32_t selected_item, Configuration_Menu_Icon_Row* config) +{ + int16_t X_Target = coordinates->X + DISPLAY_X_CENTER - selected_item * config->Icon_Space_Width; + + int Move_Direction = _NONE; + if(X_Target > _Menu_Icon_Row_Current_X) { + Move_Direction = _RIGHT; + } else if(X_Target < _Menu_Icon_Row_Current_X) { + Move_Direction = _LEFT; + } + + int16_t Distance = abs(X_Target - _Menu_Icon_Row_Current_X); + float Scale_Factor_Strength = fabsf(((float)Distance / (float)config->Icon_Space_Width)); + + _Menu_Icon_Row_Current_X += (((Distance >> 1) + 1) * Move_Direction); + + int16_t X = _Menu_Icon_Row_Current_X; + + Display_Font_Set_Font(config->Font); + + for(uint32_t i=0;iShrink_Factor * Scale_Factor_Strength)); + Y_Warp = (int16_t)(config->Y_Images_Warp * Warp_Factor); + } + else if((i < selected_item && Move_Direction == _LEFT) || (i > selected_item && Move_Direction == _RIGHT)) { + Image_Scale = MIN(1.0, 1.0 - (config->Shrink_Factor * (1.0 - Scale_Factor_Strength)) - (config->Shrink_Factor * (Distance_Entries_From_Selected-1))); + Y_Warp = (int16_t)(config->Y_Images_Warp * (1.0 - Warp_Factor)) + (config->Y_Images_Warp * (Distance_Entries_From_Selected-1)); + } + else { + Image_Scale = MIN(1.0, 1.0 - (config->Shrink_Factor * Scale_Factor_Strength) - (config->Shrink_Factor * Distance_Entries_From_Selected)); + Y_Warp = (int16_t)(config->Y_Images_Warp * Warp_Factor) + (config->Y_Images_Warp * Distance_Entries_From_Selected); + } + + int16_t Image_X = X - (Display_Image_Get_Scaled_Width(items[i].Image, Image_Scale) >> 1); + int16_t Image_Y = coordinates->Y + config->Y_Images - Y_Warp - (Display_Image_Get_Scaled_Height(items[i].Image, Image_Scale) >> 1); + Display_Image_Draw_Color_Scaled(Image_X, Image_Y, items[i].Image, Image_Scale); + } + + if(i == selected_item) { + int16_t Title_Width = Display_Font_Width_String(items[i].Title, items[i].Title_Length, DISPLAY_DEFAULT_CHAR_SPACING); + + int16_t Text_X = coordinates->X + ((DISPLAY_WIDTH - Title_Width) >> 1); + int16_t Text_Y = coordinates->Y + config->Y_Text; + + Display_Font_Print_String(Text_X, Text_Y, items[i].Title, items[i].Title_Length, DISPLAY_DEFAULT_CHAR_SPACING, config->Color); + } + + X += config->Icon_Space_Width; + } +} + +void Display_Draw_Menu_Ring(Coordinates* coordinates, Object_Menu_Ring* menu_ring) +{ + Configuration_Menu_Ring* Config = menu_ring->Config; + + // Update animations + Display_Draw_Menu_Ring_Update_Animation_State(menu_ring); + + int16_t Center_X = coordinates->X + DISPLAY_X_CENTER; + int16_t Center_Y = coordinates->Y + DISPLAY_Y_CENTER; + + Menu_Ring_Appear_Animation* Anim = NULL; + + // Check if there is an animation datastrcutre present and if the animation is active + if (menu_ring->Appear_Animation_Active && menu_ring->Appear_Animation != NULL) { + Anim = menu_ring->Appear_Animation; + } + + if(Anim != NULL && Anim->State == MENU_RING_APPEAR_STATE_DRAWING_RING) + { + if (Anim->Ring_Draw_Angle > 0.0f) { + Display_Shapes_Draw_Arc_Frame( + Center_X, Center_Y, + Config->Item_Radius, + 2, + 0.0f, // Start from top (0 degrees) + Anim->Ring_Draw_Angle, // Current progress angle + (uint16_t)(Anim->Ring_Draw_Angle * 2), // Steps proportional to angle + Config->Selection_Ring_Color + ); + } + } + // Draw selection ring (behind items) + else + { + float Selected_Angle = Display_Draw_Menu_Ring_Get_Item_Angle(menu_ring, *menu_ring->Selected_Item); + float Total_Rotation = menu_ring->Idle_Rotation_Angle + Selected_Angle; + + Coordinates Coordinate_Dot = Display_Shapes_Polar_To_XY(Center_X, Center_Y, (uint16_t)Total_Rotation, Config->Item_Radius); + + Display_Shapes_Draw_Circle_Frame(Center_X, Center_Y, Config->Item_Radius, 2, Config->Selection_Ring_Color); + Display_Shapes_Draw_Circle_Filled(Coordinate_Dot.X, Coordinate_Dot.Y, 4, Config->Selection_Ring_Color); + } + + // Draw center circle with animated scale (both phases) + if (Anim != NULL && Anim->Center_Scale > 0.0f) + { + int16_t Scaled_Radius = (int16_t)((Config->Center_Size / 2) * Anim->Center_Scale); + + // Draw center background and border + Display_Shapes_Draw_Circle_Filled(Center_X, Center_Y, Scaled_Radius, Config->Center_BG_Color); + if (Scaled_Radius > 1) { // Avoid drawing border when too small + Display_Shapes_Draw_Circle_Frame(Center_X, Center_Y, Scaled_Radius, 2, Config->Center_Border_Color); + } + } + else + { + // Draw center area with filled circle + int16_t Radius = Config->Center_Size / 2; + Display_Shapes_Draw_Circle_Filled(Center_X, Center_Y, Radius, Config->Center_BG_Color); + Display_Shapes_Draw_Circle_Frame(Center_X, Center_Y, Radius, 2, Config->Center_Border_Color); + + // Draw center text + if (*menu_ring->Selected_Item < menu_ring->Item_Count) { + const char* Selected_Label = menu_ring->Items[*menu_ring->Selected_Item].Label; + uint8_t Label_Length = strlen(Selected_Label); + + Display_Font_Set_Font(Config->Center_Text_Font); + + // Calculate precise text positioning using actual font measurements + int16_t Text_Width = Display_Font_Width_String((char*)Selected_Label, Label_Length, DISPLAY_DEFAULT_CHAR_SPACING); + int16_t Text_X = Center_X - (Text_Width / 2); + int16_t Text_Y = Center_Y - Display_Font_Get_Font_Height() / 2; + + // Draw the selected item's label with perfect centering + Display_Font_Print_String(Text_X, Text_Y, (char*)Selected_Label, Label_Length, DISPLAY_DEFAULT_CHAR_SPACING, Config->Center_Text_Color); + } + } + + // Draw all menu items with current animation states + for (uint32_t i = 0; i < menu_ring->Item_Count; i++) + { + Menu_Ring_Item_Config* Item_Config = &menu_ring->Items[i]; + bool Is_Selected = (i == *menu_ring->Selected_Item); + + // Skip items that haven't appeared yet during appear animation + if (menu_ring->Appear_Animation_Active && menu_ring->Item_Scales[i] <= 0.0f) { + continue; + } + + // Calculate item position + float Item_Angle = Display_Draw_Menu_Ring_Get_Item_Angle(menu_ring, i); + + Coordinates Coordinate_Base = Display_Shapes_Polar_To_XY(Center_X, Center_Y, (uint16_t)Item_Angle, Config->Item_Radius); + + // Get current scale for this item + float Current_Scale = menu_ring->Item_Scales[i]; + + // Draw the item (image or fallback circle) + if (Item_Config->Icon != NULL && Current_Scale > 0.0f) { + // Calculate centered position for scaled image + int16_t Image_X = Coordinate_Base.X - (Display_Image_Get_Scaled_Width(Item_Config->Icon, Current_Scale) / 2); + int16_t Image_Y = Coordinate_Base.Y - (Display_Image_Get_Scaled_Height(Item_Config->Icon, Current_Scale) / 2); + + // Draw the scaled image + Display_Image_Draw_Color_Scaled(Image_X, Image_Y, Item_Config->Icon, Current_Scale); + } else if (Current_Scale > 0.0f) { + // Fallback: Draw simple filled circle if no image + int16_t Circle_Radius = (int16_t)((Config->Image_Size / 2) * Current_Scale); + Display_Shapes_Draw_Circle_Filled(Coordinate_Base.X, Coordinate_Base.Y, Circle_Radius, Config->Selection_Ring_Color); + } + + // Draw selection border if selected (not during appear animation initial phases) + if (Is_Selected && Current_Scale > 0.0f) + { + // Don't draw selection ring during the appear animation drawing phase + if (!menu_ring->Appear_Animation_Active || (menu_ring->Appear_Animation != NULL && (menu_ring->Appear_Animation->State == MENU_RING_APPEAR_STATE_POPPING_ITEMS || menu_ring->Appear_Animation->State == MENU_RING_APPEAR_STATE_COMPLETE))) + { + int16_t Border_Radius; + + if (Config->Selection_Ring_Diameter > 0) + { + // Use explicit diameter setting + Border_Radius = (Config->Selection_Ring_Diameter / 2); + } + else if (Item_Config->Icon != NULL) + { + // Auto-calculate based on scaled image size + padding + int16_t Image_Width = Display_Image_Get_Scaled_Width(Item_Config->Icon, Current_Scale); + int16_t Image_Height = Display_Image_Get_Scaled_Height(Item_Config->Icon, Current_Scale); + int16_t max_dimension = (Image_Width > Image_Height) ? Image_Width : Image_Height; + Border_Radius = (max_dimension / 2) + Config->Selection_Ring_Padding; + } + else + { + // Fallback for items without images + Border_Radius = (Config->Image_Size / 2) + Config->Selection_Ring_Padding; + } + + // Only draw if radius is meaningful + if (Border_Radius > 1) { + Display_Shapes_Draw_Circle_Frame(Coordinate_Base.X, Coordinate_Base.Y, Border_Radius, Config->Selection_Ring_Thickness, Config->Selection_Ring_Color); + } + } + } + } +} + +void Display_Draw_Menu_Ring_Update_Animation_State(Object_Menu_Ring* menu_ring) +{ + Configuration_Menu_Ring* Config = menu_ring->Config; + + // Handle appear animation if active + if (menu_ring->Appear_Animation_Active && menu_ring->Appear_Animation != NULL) + { + Menu_Ring_Appear_Animation* Anim = menu_ring->Appear_Animation; + + switch (Anim->State) { + case MENU_RING_APPEAR_STATE_DRAWING_RING: + { + // Update ring drawing progress + if (Anim->Ring_Draw_Counter < Anim->Total_Ring_Draw_Frames) { + Anim->Ring_Draw_Counter++; + Anim->Ring_Draw_Angle = (360.0f * Anim->Ring_Draw_Counter) / Anim->Total_Ring_Draw_Frames; + } + + // Update center circle growing + if (Anim->Center_Grow_Counter < Anim->Total_Center_Grow_Frames) { + Anim->Center_Grow_Counter++; + Anim->Center_Scale = (float)Anim->Center_Grow_Counter / Anim->Total_Center_Grow_Frames; + // Apply easing for smoother growth + Anim->Center_Scale = Ease_Out_Cubic(Anim->Center_Scale); + } + + // Check if phase 1 is complete + if (Anim->Ring_Draw_Angle >= 360.0f && Anim->Center_Scale >= 1.0f) { + Anim->State = MENU_RING_APPEAR_STATE_POPPING_ITEMS; + Anim->Current_Item_Appearing = 0; + Anim->Item_Delay_Counter = Anim->Total_Item_Delay_Frames; // Start immediately + } + break; + } + + case MENU_RING_APPEAR_STATE_POPPING_ITEMS: + { + // Handle delay between items + if (Anim->Item_Delay_Counter > 0) { + Anim->Item_Delay_Counter--; + break; + } + + // Animate current item appearing + if (Anim->Current_Item_Appearing < menu_ring->Item_Count) { + Anim->Item_Pop_Counter++; + Anim->Current_Item_Scale = (float)Anim->Item_Pop_Counter / Anim->Total_Item_Pop_Frames; + + // Apply bounce easing for pop effect + float progress = Anim->Current_Item_Scale; + if (progress <= 1.0f) { + // Bounce effect: overshoot then settle + if (progress < 0.7f) { + Anim->Current_Item_Scale = progress * 1.4f; // Overshoot + } else { + float settle = (progress - 0.7f) / 0.3f; + Anim->Current_Item_Scale = 1.4f - (0.4f * settle); + } + + // Update the item scale + bool Is_Selected = (Anim->Current_Item_Appearing == *menu_ring->Selected_Item); + float target_scale = Is_Selected ? Config->Selection_Scale : 1.0f; + menu_ring->Item_Scales[Anim->Current_Item_Appearing] = target_scale * Anim->Current_Item_Scale; + + if (Is_Selected) { + menu_ring->Item_Glow_Intensity[Anim->Current_Item_Appearing] = (uint8_t)(255 * Anim->Current_Item_Scale); + } + } + + // Check if current item is fully appeared + if (Anim->Item_Pop_Counter >= Anim->Total_Item_Pop_Frames) { + // Finalize current item + bool is_selected = (Anim->Current_Item_Appearing == *menu_ring->Selected_Item); + menu_ring->Item_Scales[Anim->Current_Item_Appearing] = is_selected ? Config->Selection_Scale : 1.0f; + if (is_selected) { + menu_ring->Item_Glow_Intensity[Anim->Current_Item_Appearing] = 255; + } + + // Move to next item + Anim->Current_Item_Appearing++; + Anim->Item_Pop_Counter = 0; + Anim->Current_Item_Scale = 0.0f; + Anim->Item_Delay_Counter = Anim->Total_Item_Delay_Frames; + } + } else { + // All items have appeared + Anim->State = MENU_RING_APPEAR_STATE_COMPLETE; + menu_ring->Appear_Animation_Active = false; + } + break; + } + + case MENU_RING_APPEAR_STATE_COMPLETE: + case MENU_RING_APPEAR_STATE_IDLE: + default: + menu_ring->Appear_Animation_Active = false; + break; + } + + // Skip normal animation update if appear animation is active + if (menu_ring->Appear_Animation_Active) { + return; + } + } + + // Only update idle rotation and selection animations when appear animation is not active + if (!menu_ring->Appear_Animation_Active) + { + // Update idle rotation + menu_ring->Idle_Rotation_Angle += Config->Idle_Rotation_Speed; + if (menu_ring->Idle_Rotation_Angle >= 360.0f) { + menu_ring->Idle_Rotation_Angle -= 360.0f; + } + + // Update selection animation + if (menu_ring->Selection_Animation_Progress > 0) + { + menu_ring->Selection_Animation_Progress--; + + float Progress = 1.0f - ((float)menu_ring->Selection_Animation_Progress / Config->Animation_Duration); + float Eased_Progress = Ease_Out_Cubic(Progress); + + // Update item states + for (uint32_t i = 0; i < menu_ring->Item_Count; i++) + { + bool Is_Target = (i == menu_ring->Animation_Target); + bool Was_Selected = (i == *menu_ring->Selected_Item) && (menu_ring->Animation_Target != *menu_ring->Selected_Item); + + if (Is_Target) { + menu_ring->Item_Scales[i] = 1.0f + (Config->Selection_Scale - 1.0f) * Eased_Progress; + menu_ring->Item_Glow_Intensity[i] = (uint8_t)(255 * Eased_Progress); + } else if (Was_Selected) { + menu_ring->Item_Scales[i] = 1.0f + (Config->Selection_Scale - 1.0f) * (1.0f - Eased_Progress); + menu_ring->Item_Glow_Intensity[i] = (uint8_t)(255 * (1.0f - Eased_Progress)); + } else { + menu_ring->Item_Scales[i] = 1.0f; + menu_ring->Item_Glow_Intensity[i] = 0; + } + } + + if (menu_ring->Selection_Animation_Progress == 0) { + *menu_ring->Selected_Item = menu_ring->Animation_Target; + } + } + else + { + // Static states when not animating + for (uint32_t i = 0; i < menu_ring->Item_Count; i++) + { + if (i == *menu_ring->Selected_Item) { + menu_ring->Item_Scales[i] = Config->Selection_Scale; + menu_ring->Item_Glow_Intensity[i] = 255; + } else { + menu_ring->Item_Scales[i] = 1.0f; + menu_ring->Item_Glow_Intensity[i] = 0; + } + } + } + } + + menu_ring->Animation_Counter++; +} + +float Display_Draw_Menu_Ring_Get_Item_Angle(Object_Menu_Ring* ring_menu, uint32_t item_index) +{ + Configuration_Menu_Ring* Config = ring_menu->Config; + + if (Config->Distribute_Evenly) + { + // Evenly distribute items around the circle + float angle_step = 360.0f / ring_menu->Item_Count; + return Config->Start_Angle_Degrees + (item_index * angle_step); + } + else + { + // Use fixed angle step + return Config->Start_Angle_Degrees + (item_index * Config->Fixed_Angle_Step); + } +} + +void Display_Draw_Select_YesNo(Coordinates* coordinates, char* title, uint32_t title_length, bool value, Configuration_Select_YesNo* config) +{ + if(config == NULL) { + return; + } + + if(title != NULL && title_length > 0 && config->Title_Font != NULL) { + Display_Font_Set_Font(config->Title_Font); + int16_t Title_Width = Display_Font_Width_String(title, title_length, DISPLAY_DEFAULT_CHAR_SPACING); + + int16_t Title_X = coordinates->X + ((DISPLAY_WIDTH - Title_Width) >> 1); + int16_t Title_Y = coordinates->Y + config->Title_Y_Center - (Display_Font_Get_Font_Height() >> 1); + + Display_Font_Print_String(Title_X, Title_Y, title, title_length, DISPLAY_DEFAULT_CHAR_SPACING, config->Title_Color); + } + + if(config->Value_Font == NULL) { + return; + } + + Display_Font_Set_Font(config->Value_Font); + int16_t YesNo_Y = coordinates->Y + config->Value_Y_Center - (Display_Font_Get_Font_Height() >> 1); + + int16_t Width_Yes = Display_Font_Width_String("Yes", 3, DISPLAY_DEFAULT_CHAR_SPACING); + int16_t Width_No = Display_Font_Width_String("No", 2, DISPLAY_DEFAULT_CHAR_SPACING); + + int16_t Width_Diff = Width_Yes - Width_No; + + int16_t X_Yes = coordinates->X + DISPLAY_X_CENTER - Width_Yes - config->Value_Center_X_Offset; + int16_t X_No = coordinates->X + DISPLAY_X_CENTER + config->Value_Center_X_Offset; + + int16_t Center_Yes = X_Yes + (Width_Yes >> 1); + int16_t Center_No = X_No + (Width_No >> 1); + + int16_t Distance = Center_No - Center_Yes; + + float Distance_Ratio = fabsf((float)(_Select_YesNo_Current_X - Center_Yes) / (float)Distance); + Display_Color Color_Brackets = Display_Color_Interpolate_Float(DISPLAY_COLOR_GREEN, DISPLAY_COLOR_RED, Distance_Ratio); + Display_Color Color_Yes = Display_Color_Interpolate_Float(DISPLAY_COLOR_GREEN, DISPLAY_COLOR_DARKGREY, Distance_Ratio); + Display_Color Color_No = Display_Color_Interpolate_Float(DISPLAY_COLOR_DARKGREY, DISPLAY_COLOR_RED, Distance_Ratio); + + if(coordinates->X > 0 || coordinates->Y > 0) { + Color_Yes = DISPLAY_COLOR_DARKGREY; + Color_No = DISPLAY_COLOR_DARKGREY; + } + + Distance_Ratio = ApplyEasing1(Distance_Ratio, INOUT_EXPO); + + Display_Font_Print_String(X_Yes , YesNo_Y, "Yes", 3, DISPLAY_DEFAULT_CHAR_SPACING, Color_Yes); + Display_Font_Print_String(X_No , YesNo_Y, "No" , 2, DISPLAY_DEFAULT_CHAR_SPACING, Color_No); + + if(coordinates->X > 0 || coordinates->Y > 0) { + return; + } + + int16_t Bracket_Space_Half = (int16_t)(Width_Yes - Width_Diff * Distance_Ratio) >> 1; + + Display_Font_Print_Char(Center_Yes + Distance * Distance_Ratio - Bracket_Space_Half - Display_Font_Width_Char('[') , YesNo_Y, '[', Color_Brackets); + Display_Font_Print_Char(Center_Yes + Distance * Distance_Ratio + Bracket_Space_Half , YesNo_Y, ']', Color_Brackets); + + if(value) + { + if(_Select_YesNo_Current_X > Center_Yes) { + _Select_YesNo_Current_X -= config->Animation_Speed; + } + + if(_Select_YesNo_Current_X < Center_Yes) { + _Select_YesNo_Current_X = Center_Yes; + } + } + else + { + if(_Select_YesNo_Current_X < Center_No) { + _Select_YesNo_Current_X += config->Animation_Speed; + } + + if(_Select_YesNo_Current_X > Center_No) { + _Select_YesNo_Current_X = Center_No; + } + } +} + +void Display_Draw_Select_List(Coordinates* coordinates, char* list_titles, uint32_t list_entry_count, uint32_t list_char_length, uint32_t selected_entry, Configuration_Select_List* config) +{ + if(config == NULL) { + return; + } + + if(config->Font == NULL) { + return; + } + + Display_Font_Set_Font(config->Font); + + int16_t Entry_Height = Display_Font_Get_Font_Height(); + int16_t Total_Height = Entry_Height * list_entry_count + config->List_Entry_Y_Gap * (list_entry_count-1); + + int16_t Entry_Width = Display_Font_Width_String(&list_titles[0], list_char_length, DISPLAY_DEFAULT_CHAR_SPACING); + + int16_t X_Entires = coordinates->X + DISPLAY_X_CENTER - (Entry_Width >> 1); + int16_t Y = coordinates->Y + DISPLAY_Y_CENTER - (Total_Height >> 1); + + int16_t Y_Target = Y + selected_entry * (Entry_Height + config->List_Entry_Y_Gap); + + for(int16_t i=0;iColor_Not_Selected; + if(i==selected_entry) { + if(_Select_List_Current_Y == Y_Target) { + Color = config->Color_Selected; + } + else { + Color = Display_Color_Interpolate_Float(config->Color_Selected, config->Color_Not_Selected, (float)abs(_Select_List_Current_Y - Y_Target) / (float)Entry_Height); + } + } + + Display_Font_Print_String(X_Entires, Y, &list_titles[i*list_char_length], list_char_length, DISPLAY_DEFAULT_CHAR_SPACING, Color); + + Y += (Entry_Height + config->List_Entry_Y_Gap); + } + + if(coordinates->X > 0 || coordinates->Y > 0) { + return; + } + + Display_Shapes_Draw_Round_Rect_Frame(X_Entires-4, _Select_List_Current_Y-2, Entry_Width+8, Entry_Height+4, 5, 1, config->Color_Selected); + + int Move_Direction = _NONE; + if(_Select_List_Current_Y < Y_Target) { + Move_Direction = _DOWN; + } else if(_Select_List_Current_Y > Y_Target) { + Move_Direction = _UP; + } + + int16_t Distance = abs(Y_Target - _Select_List_Current_Y); + _Select_List_Current_Y += (((Distance >> 1) + 1) * Move_Direction); +} + +void Display_Draw_Select_Value(Coordinates* coordinates, char* title, uint32_t title_length, int32_t value, int32_t max, int32_t min, char* format, Configuration_Select_Value* config) +{ + if(config == NULL) { + return; + } + + if(title != NULL && title_length > 0 && config->Title_Font != NULL) { + Display_Font_Set_Font(config->Title_Font); + + int16_t Title_Width = Display_Font_Width_String(title, title_length, DISPLAY_DEFAULT_CHAR_SPACING); + int16_t Tilte_X = coordinates->X + ((DISPLAY_WIDTH - Title_Width) >> 1); + int16_t Title_Y = coordinates->Y + config->Title_Y_Center - (Display_Font_Get_Font_Height() >> 1); + + Display_Font_Print_String(Tilte_X, Title_Y, title, title_length, DISPLAY_DEFAULT_CHAR_SPACING, config->Title_Color); + } + + if(config->Value_Font == NULL) { + return; + } + + Display_Font_Set_Font(config->Value_Font); + + char String[64]; + int String_Length = sprintf(String, format, value); + + int16_t Value_Width = Display_Font_Width_Char('0') * String_Length + DISPLAY_DEFAULT_CHAR_SPACING * (String_Length-1); + int16_t Value_X = coordinates->X + DISPLAY_X_CENTER - (Value_Width >> 1); + int16_t Value_Y = coordinates->Y + DISPLAY_Y_CENTER- (Display_Font_Get_Font_Height() >> 1); + + Display_Font_Print_String(Value_X, Value_Y, String, String_Length, DISPLAY_DEFAULT_CHAR_SPACING, config->Value_Color); + + if(!config->Show_Arc) { + return; + } + + // ToDo, Add Arc Value Bar and End Lines here.... +} + +void Display_Draw_Select_RGB(Coordinates* coordinates, Object_Select_RGB* rgb_selector) +{ + if (rgb_selector == NULL || rgb_selector->Config == NULL || rgb_selector->Color_Value == NULL || *(rgb_selector->Current_Component) > 2) { + return; + } + + Configuration_Select_RGB* Config = rgb_selector->Config; + + // Calculate center position + int16_t Center_X = coordinates->X + DISPLAY_X_CENTER; + int16_t Center_Y = coordinates->Y + DISPLAY_Y_CENTER; + + + // Get current component value and color + uint8_t Current_Value = rgb_selector->Color_Value->Array[*(rgb_selector->Current_Component)]; + Display_Color Ring_Colors[3] = { + Config->Ring_Color_Red, + Config->Ring_Color_Green, + Config->Ring_Color_Blue + }; + Display_Color Current_Ring_Color = Ring_Colors[*(rgb_selector->Current_Component)]; + + + // Draw background ring (unfilled portion) + Display_Shapes_Draw_Circle_Frame(Center_X, Center_Y, Config->Progress_Ring_Radius, Config->Background_Ring_Thickness, Config->Background_Ring_Color); + + // Draw previous component markers first (so they appear behind current progress) + if (Config->Show_Previous_Markers == true) + { + uint16_t Marker_Ring_Radius = Config->Progress_Ring_Radius - Config->Previous_Marker_Ring_Offset; + + for (uint8_t i = 0; i < 3; i++) + { + if (i == *(rgb_selector->Current_Component)) { + continue; + } + + // Calculate angle and osition for marker + float Marker_Angle = Calculate_Progress_Ring_Angle(rgb_selector->Color_Value->Array[i], 0, 255); + Coordinates Marker_Position = Display_Shapes_Polar_To_XY(Center_X, Center_Y, Marker_Angle, Marker_Ring_Radius); + + // Draw previous marker dot + Display_Shapes_Draw_Circle_Filled(Marker_Position.X, Marker_Position.Y, Config->Previous_Marker_Radius, Ring_Colors[i]); + Display_Shapes_Draw_Circle_Frame(Marker_Position.X, Marker_Position.Y, Config->Previous_Marker_Radius + 1, 1, Config->Previous_Marker_Color); + } + } + + // Draw progress arc if value > 0 + if (Current_Value > 0) { + float Start_Angle = rgb_selector->Progress_Start_Angle; // 270° = 12 o'clock + float End_Angle = Calculate_Progress_Ring_Angle(Current_Value, 0, 255); + + Display_Shapes_Draw_Arc_Frame(Center_X, Center_Y, Config->Progress_Ring_Radius, Config->Progress_Ring_Thickness, Start_Angle, End_Angle, ARC_FRAME_AUTO_STEPS, Current_Ring_Color); + } + + // Draw value indicator dot + float Indicator_Angle = Calculate_Progress_Ring_Angle(Current_Value, 0, 255); + + Coordinates Indicator_Position = Display_Shapes_Polar_To_XY(Center_X, Center_Y, Indicator_Angle, Config->Progress_Ring_Radius); + Display_Shapes_Draw_Glow_Circle(Indicator_Position.X, Indicator_Position.Y, Config->Indicator_Radius, Config->Indicator_Core_Color, Config->Indicator_Glow_Color); + + // Draw central color preview circle + Display_Color Preview_Color = DISPLAY_COLOR_FROM_RGB888(rgb_selector->Color_Value->R, rgb_selector->Color_Value->G, rgb_selector->Color_Value->B); + Display_Shapes_Draw_Circle_Filled(Center_X, Center_Y, Config->Center_Preview_Radius, Preview_Color); + + // Draw preview circle border + Display_Shapes_Draw_Circle_Frame(Center_X, Center_Y, Config->Center_Preview_Radius, Config->Preview_Border_Thickness, Config->Preview_Border_Color); + + + // Component label (e.g., "RED") + if (Config->Component_Label_Font != NULL) + { + // Get component label + char* Component_Label = (char*)rgb_selector->Component_Labels[*rgb_selector->Current_Component]; + + Display_Font_Set_Font(Config->Component_Label_Font); + uint16_t Label_Width = Display_Font_Width_String(Component_Label, strlen(Component_Label), DISPLAY_DEFAULT_CHAR_SPACING); + int16_t Label_X = Center_X - (Label_Width / 2); + int16_t Label_Y = coordinates->Y + Config->Text_Y_Offset - 3; + + Display_Font_Print_String(Label_X, Label_Y, Component_Label, strlen(Component_Label), DISPLAY_DEFAULT_CHAR_SPACING, Config->Text_Color); + } + + + // Current value (e.g., "128/255") + if (Config->Value_Font != NULL) + { + // Draw text information at bottom + char Value_String[16]; + sprintf(Value_String, "%u/255", Current_Value); + + Display_Font_Set_Font(Config->Value_Font); + uint16_t Value_Width = Display_Font_Width_String(Value_String, strlen(Value_String), DISPLAY_DEFAULT_CHAR_SPACING); + + // Center both value and range as a group + int16_t Value_X = Center_X - (Value_Width / 2); + int16_t Value_Y = coordinates->Y + Config->Text_Y_Offset + 3 + Display_Font_Get_Font_Height(); + + Display_Font_Print_String(Value_X, Value_Y, Value_String, strlen(Value_String), DISPLAY_DEFAULT_CHAR_SPACING, Config->Text_Color); + } +} + +float Calculate_Progress_Ring_Angle(uint8_t value, uint8_t min_value, uint8_t max_value) +{ + // Convert value (0-255) to angle (0-360 degrees) + // Start from 12 o'clock position (270 degrees in standard coordinate system) + // Progress clockwise + + if (max_value <= min_value) { + return 270.0f; // Default to 12 o'clock if invalid range + } + + // Clamp value to valid range + uint8_t Clamped_Value = value; + if (Clamped_Value < min_value) { + Clamped_Value = min_value; + } + if (Clamped_Value > max_value) { + Clamped_Value = max_value; + } + + // Calculate progress as ratio (0.0 to 1.0) + float Progress_Ratio = (float)(Clamped_Value - min_value) / (float)(max_value - min_value); + + // Map to angle range: 270° to 629° (359° total, not quite full circle) + // This prevents the arc from disappearing at max value + float Angle_Degrees = 270.0f + (Progress_Ratio * 359.0f); + + // Normalize angle to 0-360 range + while (Angle_Degrees >= 360.0f) { + Angle_Degrees -= 360.0f; + } + + return Angle_Degrees; +} + +void Display_Draw_Entry_Indicator(Coordinates* coordinates, uint32_t entry_count, int32_t entry_value, Configuration_Entry_Indicator* config) +{ + if(config->Type == INDICATOR_ARC) { + Display_Draw_Entry_Indicator_Arc(coordinates, entry_count, entry_value, config); + } + else if(config->Type == INDICATOR_DOT) { + Display_Draw_Entry_Indicator_Dot(coordinates, entry_count, entry_value, config); + } +} + +void Display_Draw_Entry_Indicator_Arc(Coordinates* coordinates, uint32_t entry_count, int32_t entry_value, Configuration_Entry_Indicator* config) +{ + if(config->Type != INDICATOR_ARC) { + return; + } + + int16_t Angle_Span = config->Options.Arc.Angle_Span; + + int16_t Angle_Min = 270; + int16_t Angle_Max = 270; + + if(Angle_Span < 0) { + Angle_Min += 180; + Angle_Max += 180; + Angle_Span = abs(Angle_Span); + } + + Angle_Min -= (Angle_Span >> 1); + Angle_Max += (Angle_Span >> 1); + + float Angle_Diff = (float)abs(Angle_Max - Angle_Min); + + float Angle_Step_Per_Entry = (Angle_Diff / ((float)(entry_count << 1)-1)); + + float Angle_Target = Angle_Min + entry_value * 2 * Angle_Step_Per_Entry; + float Angle_Distance = fabsf(Angle_Target - _Entry_Indicator_Current_Angle); + + int Move_Direction = _NONE; + if(_Entry_Indicator_Current_Angle < Angle_Target && Angle_Distance > 1.0f) { + Move_Direction = _RIGHT; + } else if(_Entry_Indicator_Current_Angle > Angle_Target && Angle_Distance > 1.0f) { + Move_Direction = _LEFT; + } + + if(Move_Direction != _NONE) { + _Entry_Indicator_Current_Angle += (((Angle_Distance / 2) + 1) * Move_Direction); + } + else { + _Entry_Indicator_Current_Angle = Angle_Target; + } + + + float Angle_Start = Angle_Min; + float Angle_End = Angle_Min + Angle_Step_Per_Entry; + + for(int i=0;i<(entry_count << 1)-1;i++) + { + if(i%2 == 0 && fabsf(Angle_Start - _Entry_Indicator_Current_Angle) > 1.0f) { + Display_Shapes_Draw_Arc_Frame(coordinates->X + DISPLAY_X_CENTER, coordinates->Y + DISPLAY_Y_CENTER, config->Options.Arc.Radius, config->Options.Arc.Thickness, Angle_Start, Angle_End, 10, config->Color_Unselected); + } + + Angle_Start += Angle_Step_Per_Entry; + Angle_End += Angle_Step_Per_Entry; + } + + Display_Shapes_Draw_Arc_Frame(DISPLAY_X_CENTER, DISPLAY_Y_CENTER, config->Options.Arc.Radius, config->Options.Arc.Thickness, _Entry_Indicator_Current_Angle, _Entry_Indicator_Current_Angle+Angle_Step_Per_Entry, 10, config->Color_Selected); +} + +void Display_Draw_Entry_Indicator_Dot(Coordinates* coordinates, uint32_t entry_count, int32_t entry_value, Configuration_Entry_Indicator* config) +{ + if(config->Type != INDICATOR_DOT) { + return; + } + + int16_t Width_Total = (entry_count-1) * config->Options.Dot.Dot_Distance; + + int16_t X = coordinates->X + DISPLAY_X_CENTER - (Width_Total >> 1); + + int16_t X_Target = X + entry_value * config->Options.Dot.Dot_Distance;; + int16_t X_Distance = abs(X_Target - _Entry_Indicator_Current_X); + + int Move_Direction = _NONE; + if(_Entry_Indicator_Current_X < X_Target) { + Move_Direction = _RIGHT; + } else if(_Entry_Indicator_Current_X > X_Target) { + Move_Direction = _LEFT; + } + + if(Move_Direction != _NONE) { + _Entry_Indicator_Current_X += (((X_Distance >> 1) + 1) * Move_Direction); + } + + for(int i=0;iY + config->Options.Dot.Y; + + if(X != _Entry_Indicator_Current_X) { + if(config->Options.Dot.Unselected_Frame_Only) { + Display_Shapes_Draw_Circle_Frame(X, Dot_Y, config->Options.Dot.Dot_Size, 1, config->Color_Unselected); + } + else { + Display_Shapes_Draw_Circle_Filled(X, Dot_Y, config->Options.Dot.Dot_Size, config->Color_Unselected); + } + } + + X += config->Options.Dot.Dot_Distance; + } + + if(coordinates->X > 0 || coordinates->Y > 0) { + return; + } + + Display_Shapes_Draw_Circle_Filled(_Entry_Indicator_Current_X, config->Options.Dot.Y, config->Options.Dot.Dot_Size, config->Color_Selected); +} + +void Display_Draw_Focused(Coordinates* coordinates, uint width, uint height) +{ + if(_Object_Selected == true) + { + Display_Shapes_Draw_Rect_Filled(coordinates->X, coordinates->Y, 3, 3, DISPLAY_COLOR_RED); + } + else + { + Display_Shapes_Draw_Rect_Filled(coordinates->X, coordinates->Y, 3, 3, DISPLAY_COLOR_GREEN); + } +} + +Animation_State Display_Animation_Tick(Display_Object* object) +{ + Animation* Animation = object->Animation; + Animation_Status* Animation_Status = object->Animation_Status; + + if(Animation == NULL || Animation_Status == NULL) { + return COMPLETE; + } + + switch (Animation_Status->State) + { + case NO_STARTED: + Animation_Status->Target.X = object->Coordinates.X; + Animation_Status->Target.Y = object->Coordinates.Y; + +// break; // Skipped on purpose + + case DELAYING: + if(Animation_Status->State == DELAYING) { + Animation_Status->Tick_Counter--; + } else { + Animation_Status->Tick_Counter = Animation->Tick_Delay; + Animation_Status->State = DELAYING; + } + + if(Animation_Status->Tick_Counter > 0) { + break; + } + +// break; // Skipped on purpose + + case MOVING: + if(Animation_Status->State == MOVING) { + Animation_Status->Tick_Counter--; + } else { + Animation_Status->Tick_Counter = Animation->Tick_Duration; + Animation_Status->State = MOVING; + } + + float Progress = (float)Animation_Status->Tick_Counter / (float)Animation->Tick_Duration; + + object->Coordinates.X = Animation_Status->Target.X + (int16_t)((float)Animation->Offset.X * Progress); + object->Coordinates.Y = Animation_Status->Target.Y + (int16_t)((float)Animation->Offset.Y * Progress); + + if(Animation_Status->Tick_Counter == 0) { + Animation_Status->State = COMPLETE; + } + break; + + case COMPLETE: + default: + Animation_Status->State = COMPLETE; + break; + } + + return Animation_Status->State; +} + +void Display_Draw_Touch_Refernce_Points(Display_Color color) +{ + for(int i=0;iX-5, Point->Y-5, 5, color); + } + } +} + +void Display_Draw_Touch_Marker(Display_Color color) +{ + int Radius = 5; + uint Marker_Count = Display_Touch_Get_Marker_Count(); + + for(uint i=0;iX-Radius, Coordinates->Y-Radius, Radius, color); + } +} + +void Display_Draw_Center_Lines(Display_Color color) +{ + Display_Shapes_Draw_HLine(0, DISPLAY_HEIGHT/2 - 1, DISPLAY_WIDTH, 2, color); + Display_Shapes_Draw_VLine(DISPLAY_WIDTH/2 - 1, 0, DISPLAY_HEIGHT, 2, color); +} + +void Display_Check_Button_Touch(int16_t x, int16_t y) +{ + for(uint i=0;iType != BUTTON) { continue; } + + Coordinates Coordinates = Object->Coordinates; + Style* Style = Object->Style; + Object_Button* N = (Object_Button*)Object->Data; + + if(Style != NULL) { + Display_Draw_Style(&Coordinates, Style, N->Dimension.Width, N->Dimension.Height, false); + } + + if(x >= Coordinates.X && x <= Coordinates.X + N->Dimension.Width && y >= Coordinates.Y && y <= Coordinates.Y + N->Dimension.Height) + { + _Touched_Button_Return_Value = N->Return_Value; + } + } +} + +void Display_Object_Select_Next(void) +{ + Display_Object* Current_Object = Display_Get_Selected_Object(); + int Current_Object_Index = Display_Get_Index_Of_Object(Current_Object); + + if(Current_Object_Index == -1) + { + Current_Object_Index = 0; + Current_Object = Display_Objects_Get_By_ID(Current_Object_Index); + if(Current_Object->Selectable == true && Current_Object->Enabled == true) + { + Current_Object->Focused = true; + return; + } + } + + for(uint i=0;i= Display_Objects_Count()) + { + Index -= Display_Objects_Count(); + } + + Display_Object* Next_Possible_Object = Display_Objects_Get_By_ID(Index); + + if(Next_Possible_Object->Selectable == true && Next_Possible_Object->Enabled == true) + { + Current_Object->Focused = false; + Next_Possible_Object->Focused = true; + return; + } + } +} + +void Display_Object_Select_Previous(void) +{ + Display_Object* Current_Object = Display_Get_Selected_Object(); + int Current_Object_Index = Display_Get_Index_Of_Object(Current_Object); + + if(Current_Object_Index == -1) + { + Current_Object_Index = 0; + } + + for(uint i=0;i= Display_Objects_Count()) + { + Index -= Display_Objects_Count(); + } + + Display_Object* Next_Possible_Object = Display_Objects_Get_By_ID(Index); + + if(Next_Possible_Object->Selectable == true && Next_Possible_Object->Enabled == true) + { + Current_Object->Focused = false; + Next_Possible_Object->Focused = true; + return; + } + } + + if(Current_Object->Selectable == true && Current_Object->Enabled == true) + { + Current_Object->Focused = true; + } +} + +Display_Object* Display_Get_Selected_Object(void) +{ + for(uint i=0;iSelectable == true && Object->Focused == true) + { + return Object; + } + } + + return NULL; +} + +int Display_Get_Index_Of_Object(Display_Object* object) +{ + if(object == NULL) { return -1; } + + for(uint i=0;i= DISPLAY_WIDTH) { + // Clear entire buffer + Display_Shapes_Fill_Screen(Display_Objects_Background_Color_Get()); + return; + } + + Display_Color BG_Color = Display_Objects_Background_Color_Get(); + + // Move columns to the left + for (int16_t row = 0; row < DISPLAY_HEIGHT; row++) + { + // Move the row data left + memmove(&_Current_Buffer->Dim_2[row][0], &_Current_Buffer->Dim_2[row][steps], (DISPLAY_WIDTH - steps) * sizeof(Display_Color)); + + // Fill the rightmost area with background color + for (int16_t col = DISPLAY_WIDTH - steps; col < DISPLAY_WIDTH; col++) { + _Current_Buffer->Dim_2[row][col] = BG_Color; + } + } +} + +void Display_Buffer_Shift_Right(uint32_t steps) +{ + if (steps >= DISPLAY_WIDTH) { + Display_Shapes_Fill_Screen(Display_Objects_Background_Color_Get()); + return; + } + + Display_Color BG_Color = Display_Objects_Background_Color_Get(); + + // Move columns to the right (start from rightmost to avoid overwriting) + for (int16_t row = 0; row < DISPLAY_HEIGHT; row++) + { + // Move the row data right + memmove(&_Current_Buffer->Dim_2[row][steps], &_Current_Buffer->Dim_2[row][0], (DISPLAY_WIDTH - steps) * sizeof(Display_Color)); + + // Fill the leftmost area with background color + for (int16_t col = 0; col < steps; col++) { + _Current_Buffer->Dim_2[row][col] = BG_Color; + } + } +} + +void Display_Buffer_Shift_Up(uint32_t steps) +{ + if (steps >= DISPLAY_HEIGHT) { + Display_Shapes_Fill_Screen(Display_Objects_Background_Color_Get()); + return; + } + + // Calculate how many pixels to move + uint32_t Pixels_To_Move = DISPLAY_WIDTH * (DISPLAY_HEIGHT - steps); + + // Single memmove for the entire shift operation + memmove(&_Current_Buffer->Dim_1[0], &_Current_Buffer->Dim_1[DISPLAY_WIDTH * steps], Pixels_To_Move * sizeof(Display_Color)); + + // Fill the bottom area using optimized rectangle fill + Display_Shapes_Draw_Rect_Filled(0, DISPLAY_HEIGHT - steps, DISPLAY_WIDTH, steps, Display_Objects_Background_Color_Get()); +} + +void Display_Buffer_Shift_Down(uint32_t steps) +{ + if (steps >= DISPLAY_HEIGHT) { + Display_Shapes_Fill_Screen(Display_Objects_Background_Color_Get()); + return; + } + + // Calculate how many pixels to move + uint32_t Pixels_To_Move = DISPLAY_WIDTH * (DISPLAY_HEIGHT - steps); + + // Single memmove for the entire shift operation + memmove(&_Current_Buffer->Dim_1[DISPLAY_WIDTH * steps], &_Current_Buffer->Dim_1[0], Pixels_To_Move * sizeof(Display_Color)); + + // Fill the top area using optimized rectangle fill + Display_Shapes_Draw_Rect_Filled(0, 0, DISPLAY_WIDTH, steps, Display_Objects_Background_Color_Get()); +} + +void Display_Copy_Buffer(Display_Image_Buffer *src, Display_Image_Buffer *dest) +{ + dma_channel_configure(_DMA_Channel_Copy_Buffer, &_DMA_Config_Copy_Buffer, dest, src, DISPLAY_IMAGE_BUFFER_PIXEL_SIZE/2, false); + dma_channel_start(_DMA_Channel_Copy_Buffer); + dma_channel_wait_for_finish_blocking(_DMA_Channel_Copy_Buffer); +} \ No newline at end of file diff --git a/Firmware/Display.h b/Firmware/Display.h new file mode 100644 index 0000000..8231b65 --- /dev/null +++ b/Firmware/Display.h @@ -0,0 +1,63 @@ +/* + * Display.h + * + * Created: Sun Mar 21 2021 15:51:51 + * Author Chris + */ +#ifndef DISPLAY_H_ +#define DISPLAY_H_ + +// ============================================================================================ +// Includes +#include +#include +#include + +#include "Display_Config.h" +#include "Display_Objects.h" + +#include "Easings.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Display_Init(Display_Color initial_color, bool send_buffer, bool init_touch); + +void Display_Issue_Touch_Event(int16_t x_screen, int16_t y_screen); +void Display_Set_Draw_Touch_Reference_Points(bool do_draw); +void Display_Set_Draw_Center_Lines(bool do_draw); + +void Display_Screen_Transition_Start(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration); +void Display_Screen_Transition_Tick(); + +void Display_Render_Objects(void); +void Display_Send_Buffer(void); +bool Display_Send_Buffer_Completed(void); + +void Display_Show_Test_Screen(void); + +int Display_Get_Button_Touch_Return_Value(void); +void Display_Select_First_Object(void); +void Display_Action_CW(void); +void Display_Action_CCW(void); +void Display_Action_SW(void); +void Display_Select_Object(void); +void Display_Unselect_Object(void); + +void Display_Menu_Icon_Row_Set(uint32_t initially_selected_item, uint32_t icon_space_width); + +void Display_Inc_Frame_Counter(void); +uint* Display_Get_Frame_Counter_Reference(void); + +void Display_Set_Debug_Print(void); + + +#endif /* DISPLAY_H_ */ \ No newline at end of file diff --git a/Firmware/Display_Color.c b/Firmware/Display_Color.c new file mode 100644 index 0000000..0057151 --- /dev/null +++ b/Firmware/Display_Color.c @@ -0,0 +1,127 @@ +/* + * Display_Color.c + * + * Created: Mon Jun 23 2025 13:15:42 + * Author Chris + */ +#include "Display_Color.h" + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ +/** + * Interpolate between two RGB565 colors + * @param start_color Starting color in RGB565 format + * @param end_color Ending color in RGB565 format + * @param factor Interpolation factor (0.0 = start_color, 1.0 = end_color) + * @return Interpolated color in RGB565 format + */ +Display_Color Display_Color_Interpolate_Float(Display_Color start_color, Display_Color end_color, float factor) +{ + // Clamp factor to [0, 1] range + if (factor <= 0.0f) return start_color; + if (factor >= 1.0f) return end_color; + + int Start_R = RED_FROM_RGB565(start_color); + int Start_G = GREEN_FROM_RGB565(start_color); + int Start_B = BLUE_FROM_RGB565(start_color); + + int End_R = RED_FROM_RGB565(end_color); + int End_G = GREEN_FROM_RGB565(end_color); + int End_B = BLUE_FROM_RGB565(end_color); + + // Interpolate each component + int Interp_R = Start_R + (int)((float)(End_R - Start_R) * factor); + int Interp_G = Start_G + (int)((float)(End_G - Start_G) * factor); + int Interp_B = Start_B + (int)((float)(End_B - Start_B) * factor); + + return DISPLAY_COLOR_FROM_RGB565(Interp_R, Interp_G, Interp_B); +} + +/** + * Alternative integer-only version for better performance on RP2350 + * Uses fixed-point arithmetic to avoid floating point operations + * @param start_color Starting color in RGB565 format + * @param end_color Ending color in RGB565 format + * @param factor Interpolation factor as integer (0-256, where 256 = 1.0) + * @return Interpolated color in RGB565 format + */ +Display_Color Display_Color_Interpolate_Fixpoint(Display_Color start_color, Display_Color end_color, uint16_t factor) +{ + // Clamp factor to [0, 256] range + if (factor == 0) return start_color; + if (factor >= 256) return end_color; + + int Start_R = RED_FROM_RGB565(start_color); + int Start_G = GREEN_FROM_RGB565(start_color); + int Start_B = BLUE_FROM_RGB565(start_color); + + int End_R = RED_FROM_RGB565(end_color); + int End_G = GREEN_FROM_RGB565(end_color); + int End_B = BLUE_FROM_RGB565(end_color); + + // Interpolate using fixed-point arithmetic + uint16_t Interp_R = Start_R + (((End_R - Start_R) * factor) >> 8); + uint16_t Interp_G = Start_G + (((End_G - Start_G) * factor) >> 8); + uint16_t Interp_B = Start_B + (((End_B - Start_B) * factor) >> 8); + + return DISPLAY_COLOR_FROM_RGB565(Interp_R, Interp_G, Interp_B); +} + +/** + * Fast RGB565 alpha blending using fixed-point arithmetic + * Optimized for RP2350's ARM Cortex-M33 + * @param src_color Source color in RGB565 format + * @param dst_color Destination color in RGB565 format (from buffer) + * @param alpha Alpha value (0-255, where 255 = fully opaque) + * @return Blended color in RGB565 format + */ +__attribute__((always_inline)) +inline Display_Color Display_Color_Blend_RGB565(Display_Color src_color, Display_Color dst_color, uint8_t alpha) +{ + // Early exit for fully opaque/transparent + if (alpha == UINT8_MAX) { + return src_color; + } + + if (alpha == 0) { + return dst_color; + } + + // Extract RGB components from source + uint16_t Src_R = RED_FROM_RGB565(src_color); + uint16_t Src_G = GREEN_FROM_RGB565(src_color); + uint16_t Src_B = BLUE_FROM_RGB565(src_color); + + // Extract RGB components from destination + uint16_t Dst_R = RED_FROM_RGB565(dst_color); + uint16_t Dst_G = GREEN_FROM_RGB565(dst_color); + uint16_t Dst_B = BLUE_FROM_RGB565(dst_color); + + // Alpha blend using fixed-point arithmetic (alpha already 0-255) + // Formula: result = (src * alpha + dst * (255 - alpha)) / 255 + uint16_t Inv_Alpha = 255 - alpha; + + uint16_t Blended_R = (Src_R * alpha + Dst_R * Inv_Alpha + 128) / 255; + uint16_t Blended_G = (Src_G * alpha + Dst_G * Inv_Alpha + 128) / 255; + uint16_t Blended_B = (Src_B * alpha + Dst_B * Inv_Alpha + 128) / 255; + + return DISPLAY_COLOR_FROM_RGB565(Blended_R, Blended_G, Blended_B); +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ \ No newline at end of file diff --git a/Firmware/Display_Color.h b/Firmware/Display_Color.h new file mode 100644 index 0000000..e750577 --- /dev/null +++ b/Firmware/Display_Color.h @@ -0,0 +1,31 @@ +/* + * Display_Color.h + * + * Created: Mon Jun 23 2025 13:15:17 + * Author Chris + */ +#ifndef DISPLAY_COLOR_H_ +#define DISPLAY_COLOR_H_ + +// ============================================================================================ +// Includes +#include + +#include "Display_Config.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +Display_Color Display_Color_Interpolate_Float(Display_Color start_color, Display_Color end_color, float factor); +Display_Color Display_Color_Interpolate_Fixpoint(Display_Color start_color, Display_Color end_color, uint16_t factor); +Display_Color Display_Color_Blend_RGB565(Display_Color src_color, Display_Color dst_color, uint8_t alpha); + +#endif /* DISPLAY_COLOR_H_ */ diff --git a/Firmware/Display_Config.h b/Firmware/Display_Config.h new file mode 100644 index 0000000..0355072 --- /dev/null +++ b/Firmware/Display_Config.h @@ -0,0 +1,306 @@ +/* + * Display_Config.h + * + * Created: Sun Mar 21 2021 16:11:51 + * Author Chris + */ +#ifndef DISPLAY_CONFIG_H_ +#define DISPLAY_CONFIG_H_ + +// ============================================================================================ +// Includes +#include +#include +#include + +#include "pico/types.h" +#include "pico/stdlib.h" +#include "hardware/spi.h" +#include "hardware/structs/spi.h" + + +// ============================================================================================ +// Defines +#define YES 1 +#define NO 0 + + +/******************************************************************* + Pin and Interface Definitions +*******************************************************************/ +#define DISPLAY_SPI_PORT spi0 +#define DISPLAY_SPI_PIN_CS 21 +#define DISPLAY_SPI_PIN_SCK 22 +#define DISPLAY_SPI_PIN_MOSI 19 +#define DISPLAY_PIN_RESET 16 +#define DISPLAY_PIN_COMMAND 20 + +#define DISPLAY_SPI_PIN_MISO 4 // Only required if Touch Screen is used +#define DISPLAY_SPI_PIN_CS_TOUCH 6 // Only required if Touch Screen is used + +// #define DISPLAY_SPI_BAUDRATE 50000000 // results in 37,5 MHz +#define DISPLAY_SPI_BAUDRATE 100000000 // results in 75 MHz + +#define DISPLAY_MODE_SET_CMD() gpio_put(DISPLAY_PIN_COMMAND, 0) // Macro for setting TFT mode signal low (command) +#define DISPLAY_MODE_SET_DATA() gpio_put(DISPLAY_PIN_COMMAND, 1) // Macro for setting TFT mode signal (data) +#define DISPLAY_RESET_ON() gpio_put(DISPLAY_PIN_RESET, 0) +#define DISPLAY_RESET_OFF() gpio_put(DISPLAY_PIN_RESET, 1) + + +/******************************************************************* + Display Definitions +*******************************************************************/ +// #define DISPLAY_ILI9341 +// #define DISPLAY_ST7735 +#define DISPLAY_GC9A01A + +#ifdef DISPLAY_ILI9341 + #define DISPLAY_WIDTH 320 // Width of display using default orientation + #define DISPLAY_HEIGHT 240 // Height of display using default orientation +#elif defined(DISPLAY_ST7735) + #define DISPLAY_WIDTH 160 // Width of display using default orientation + #define DISPLAY_HEIGHT 128 // Height of display using default orientation +#elif defined(DISPLAY_GC9A01A) + #define DISPLAY_WIDTH 240 // Width of display using default orientation + #define DISPLAY_HEIGHT 240 // Height of display using default orientation +#endif + + +//////////////////////////// +// DISPLAY MAIN DATATYPES // +//////////////////////////// +typedef uint16_t Display_Color; + +#define DISPLAY_IMAGE_BUFFER_PIXEL_SIZE (DISPLAY_WIDTH*DISPLAY_HEIGHT) +#define DISPLAY_IMAGE_BUFFER_BYTE_SIZE (DISPLAY_IMAGE_BUFFER_PIXEL_SIZE*sizeof(Display_Color)) +#define DISPLAY_X_CENTER (DISPLAY_WIDTH >> 1) +#define DISPLAY_Y_CENTER (DISPLAY_HEIGHT >> 1) + +typedef union +{ + Display_Color Dim_2[DISPLAY_HEIGHT][DISPLAY_WIDTH]; + Display_Color Dim_1[DISPLAY_IMAGE_BUFFER_PIXEL_SIZE]; +} __aligned(4) Display_Image_Buffer; + + +/////////////////////////// +// DISPLAY CONFIGURATION // +/////////////////////////// +#define DISPLAY_FLIP_X NO +#define DISPLAY_FLIP_Y YES +#define DISPLAY_X_Y_EXCHANGE NO +#define DISPLAY_INVERT_COLORS NO +#define DISPLAY_DEFAULT_CHAR_SPACING 2 + + +/////////////////////////////// +// DISPLAY COLOR DEFINITIONS // +/////////////////////////////// +#if DISPLAY_INVERT_COLORS==NO + #define DISPLAY_COLOR_FROM_RGB888(r, g, b) ((Display_Color)b & 0x00F8) | (((Display_Color)r << 5) & 0x1F00) | ((Display_Color)g >> 5) | (((Display_Color)g << 11) & 0xE000) + #define DISPLAY_COLOR_FROM_RGB565(r, g, b) (((Display_Color)b << 3) & 0x00F8) | (((Display_Color)r << 8) & 0x1F00) | ((Display_Color)g >> 3) | (((Display_Color)g << 11) & 0xE000) + + #define RED_FROM_RGB565(_color_) (Display_Color)((_color_ & 0x1F00) >> 8) + #define GREEN_FROM_RGB565(_color_) (Display_Color)(((_color_ & 0xE000) >> 11) | ((_color_ & 0x0007) << 3)) + #define BLUE_FROM_RGB565(_color_) (Display_Color)((_color_ & 0x00F8) >> 3) +#else + #define DISPLAY_COLOR_FROM_RGB888(r, g, b) ((Display_Color)r & 0x00F8) | (((Display_Color)b << 5) & 0x1F00) | ((Display_Color)g >> 5) | (((Display_Color)g << 11) & 0xE000) +#endif + +#define DISPLAY_COLOR_BLACK DISPLAY_COLOR_FROM_RGB888( 0, 0, 0) +#define DISPLAY_COLOR_NAVY DISPLAY_COLOR_FROM_RGB888( 0, 0, 128) +#define DISPLAY_COLOR_DARKGREEN DISPLAY_COLOR_FROM_RGB888( 0, 128, 0) +#define DISPLAY_COLOR_DARKCYAN DISPLAY_COLOR_FROM_RGB888( 0, 128, 128) +#define DISPLAY_COLOR_MAROON DISPLAY_COLOR_FROM_RGB888(128, 0, 0) +#define DISPLAY_COLOR_PURPLE DISPLAY_COLOR_FROM_RGB888(128, 0, 128) +#define DISPLAY_COLOR_OLIVE DISPLAY_COLOR_FROM_RGB888(128, 128, 0) +#define DISPLAY_COLOR_LIGHTGREY DISPLAY_COLOR_FROM_RGB888(192, 192, 192) +#define DISPLAY_COLOR_DARKGREY DISPLAY_COLOR_FROM_RGB888(128, 128, 128) +#define DISPLAY_COLOR_BLUE DISPLAY_COLOR_FROM_RGB888( 0, 0, 255) +#define DISPLAY_COLOR_GREEN DISPLAY_COLOR_FROM_RGB888( 0, 255, 0) +#define DISPLAY_COLOR_CYAN DISPLAY_COLOR_FROM_RGB888( 0, 255, 255) +#define DISPLAY_COLOR_RED DISPLAY_COLOR_FROM_RGB888(255, 0, 0) +#define DISPLAY_COLOR_MAGENTA DISPLAY_COLOR_FROM_RGB888(255, 0, 255) +#define DISPLAY_COLOR_YELLOW DISPLAY_COLOR_FROM_RGB888(255, 255, 0) +#define DISPLAY_COLOR_WHITE DISPLAY_COLOR_FROM_RGB888(255, 255, 255) +#define DISPLAY_COLOR_ORANGE DISPLAY_COLOR_FROM_RGB888(255, 165, 0) +#define DISPLAY_COLOR_GREENYELLOW DISPLAY_COLOR_FROM_RGB888(173, 255, 47) +#define DISPLAY_COLOR_PINK DISPLAY_COLOR_FROM_RGB888(255, 0, 255) + + + +#ifdef DISPLAY_ILI9341 + // Level 1 Commands (from the display Datasheet) + #define ILI9341_CMD_NOP 0x00 + #define ILI9341_CMD_SOFTWARE_RESET 0x01 + #define ILI9341_CMD_READ_DISP_ID 0x04 + #define ILI9341_CMD_READ_DISP_STATUS 0x09 + #define ILI9341_CMD_READ_DISP_MADCTRL 0x0B + #define ILI9341_CMD_READ_DISP_PIXEL_FORMAT 0x0C + #define ILI9341_CMD_READ_DISP_IMAGE_FORMAT 0x0D + #define ILI9341_CMD_READ_DISP_SIGNAL_MODE 0x0E + #define ILI9341_CMD_READ_DISP_SELF_DIAGNOSTIC 0x0F + #define ILI9341_CMD_ENTER_SLEEP_MODE 0x10 + #define ILI9341_CMD_SLEEP_OUT 0x11 + #define ILI9341_CMD_PARTIAL_MODE_ON 0x12 + #define ILI9341_CMD_NORMAL_DISP_MODE_ON 0x13 + #define ILI9341_CMD_DISP_INVERSION_OFF 0x20 + #define ILI9341_CMD_DISP_INVERSION_ON 0x21 + #define ILI9341_CMD_GAMMA_SET 0x26 + #define ILI9341_CMD_DISPLAY_OFF 0x28 + #define ILI9341_CMD_DISPLAY_ON 0x29 + #define ILI9341_CMD_COLUMN_ADDRESS_SET 0x2A + #define ILI9341_CMD_PAGE_ADDRESS_SET 0x2B + #define ILI9341_CMD_MEMORY_WRITE 0x2C + #define ILI9341_CMD_COLOR_SET 0x2D + #define ILI9341_CMD_MEMORY_READ 0x2E + #define ILI9341_CMD_PARTIAL_AREA 0x30 + #define ILI9341_CMD_VERT_SCROLL_DEFINITION 0x33 + #define ILI9341_CMD_TEARING_EFFECT_LINE_OFF 0x34 + #define ILI9341_CMD_TEARING_EFFECT_LINE_ON 0x35 + #define ILI9341_CMD_MEMORY_ACCESS_CONTROL 0x36 + #define ILI9341_CMD_VERT_SCROLL_START_ADDRESS 0x37 + #define ILI9341_CMD_IDLE_MODE_OFF 0x38 + #define ILI9341_CMD_IDLE_MODE_ON 0x39 + #define ILI9341_CMD_COLMOD_PIXEL_FORMAT_SET 0x3A + #define ILI9341_CMD_WRITE_MEMORY_CONTINUE 0x3C + #define ILI9341_CMD_READ_MEMORY_CONTINUE 0x3E + #define ILI9341_CMD_SET_TEAR_SCANLINE 0x44 + #define ILI9341_CMD_GET_SCANLINE 0x45 + #define ILI9341_CMD_WRITE_DISPLAY_BRIGHTNESS 0x51 + #define ILI9341_CMD_READ_DISPLAY_BRIGHTNESS 0x52 + #define ILI9341_CMD_WRITE_CTRL_DISPLAY 0x53 + #define ILI9341_CMD_READ_CTRL_DISPLAY 0x54 + #define ILI9341_CMD_WRITE_CONTENT_ADAPT_BRIGHTNESS 0x55 + #define ILI9341_CMD_READ_CONTENT_ADAPT_BRIGHTNESS 0x56 + #define ILI9341_CMD_WRITE_MIN_CAB_LEVEL 0x5E + #define ILI9341_CMD_READ_MIN_CAB_LEVEL 0x5F + #define ILI9341_CMD_READ_ID1 0xDA + #define ILI9341_CMD_READ_ID2 0xDB + #define ILI9341_CMD_READ_ID3 0xDC + + // Level 2 Commands (from the display Datasheet) + #define ILI9341_CMD_RGB_SIGNAL_CONTROL 0xB0 + #define ILI9341_CMD_FRAME_RATE_CONTROL_NORMAL 0xB1 + #define ILI9341_CMD_FRAME_RATE_CONTROL_IDLE_8COLOR 0xB2 + #define ILI9341_CMD_FRAME_RATE_CONTROL_PARTIAL 0xB3 + #define ILI9341_CMD_DISPLAY_INVERSION_CONTROL 0xB4 + #define ILI9341_CMD_BLANKING_PORCH_CONTROL 0xB5 + #define ILI9341_CMD_DISPLAY_FUNCTION_CONTROL 0xB6 + #define ILI9341_CMD_ENTRY_MODE_SET 0xB7 + #define ILI9341_CMD_BACKLIGHT_CONTROL_1 0xB8 + #define ILI9341_CMD_BACKLIGHT_CONTROL_2 0xB9 + #define ILI9341_CMD_BACKLIGHT_CONTROL_3 0xBA + #define ILI9341_CMD_BACKLIGHT_CONTROL_4 0xBB + #define ILI9341_CMD_BACKLIGHT_CONTROL_5 0xBC + #define ILI9341_CMD_BACKLIGHT_CONTROL_6 0xBD + #define ILI9341_CMD_BACKLIGHT_CONTROL_7 0xBE + #define ILI9341_CMD_BACKLIGHT_CONTROL_8 0xBF + #define ILI9341_CMD_POWER_CONTROL_1 0xC0 + #define ILI9341_CMD_POWER_CONTROL_2 0xC1 + #define ILI9341_CMD_VCOM_CONTROL_1 0xC5 + #define ILI9341_CMD_VCOM_CONTROL_2 0xC7 + #define ILI9341_CMD_POWER_CONTROL_A 0xCB + #define ILI9341_CMD_POWER_CONTROL_B 0xCF + #define ILI9341_CMD_NVMEM_WRITE 0xD0 + #define ILI9341_CMD_NVMEM_PROTECTION_KEY 0xD1 + #define ILI9341_CMD_NVMEM_STATUS_READ 0xD2 + #define ILI9341_CMD_READ_ID4 0xD3 + #define ILI9341_CMD_POSITIVE_GAMMA_CORRECTION 0xE0 + #define ILI9341_CMD_NEGATIVE_GAMMA_CORRECTION 0xE1 + #define ILI9341_CMD_DIGITAL_GAMMA_CONTROL_1 0xE2 + #define ILI9341_CMD_DIGITAL_GAMMA_CONTROL_2 0xE3 + #define ILI9341_CMD_DRIVER_TIMING_CONTROL_A 0xE8 + #define ILI9341_CMD_DRIVER_TIMING_CONTROL_B 0xEA + #define ILI9341_CMD_ENABLE_3_GAMMA_CONTROL 0xF2 + #define ILI9341_CMD_INTERFACE_CONTROL 0xF6 + #define ILI9341_CMD_PUMP_RATIO_CONTROL 0xF7 +#elif defined(DISPLAY_ST7735) + #define ST77XX_SLPOUT 0x11 + #define ST77XX_NORON 0x13 + #define ST77XX_INVOFF 0x20 + #define ST77XX_DISPON 0x29 + #define ST77XX_CASET 0x2A + #define ST77XX_RASET 0x2B + #define ST77XX_MEM_WR 0x2C + #define ST77XX_MADCTL 0x36 + #define ST77XX_COLMOD 0x3A + + #define ST7735_MADCTL_BGR 0x08 + #define ST7735_MADCTL_MH 0x04 + + #define ST7735_FRMCTR1 0xB1 + #define ST7735_FRMCTR2 0xB2 + #define ST7735_FRMCTR3 0xB3 + #define ST7735_INVCTR 0xB4 + #define ST7735_DISSET5 0xB6 + + #define ST7735_PWCTR1 0xC0 + #define ST7735_PWCTR2 0xC1 + #define ST7735_PWCTR3 0xC2 + #define ST7735_PWCTR4 0xC3 + #define ST7735_PWCTR5 0xC4 + #define ST7735_VMCTR1 0xC5 + + #define ST7735_PWCTR6 0xFC + + #define ST7735_GMCTRP1 0xE0 + #define ST7735_GMCTRN1 0xE1 +#elif defined(DISPLAY_GC9A01A) + #define GC9A01A_SWRESET 0x01 ///< Software Reset (maybe, not documented) + #define GC9A01A_RDDID 0x04 ///< Read display identification information + #define GC9A01A_RDDST 0x09 ///< Read Display Status + #define GC9A01A_SLPIN 0x10 ///< Enter Sleep Mode + #define GC9A01A_SLPOUT 0x11 ///< Sleep Out + #define GC9A01A_PTLON 0x12 ///< Partial Mode ON + #define GC9A01A_NORON 0x13 ///< Normal Display Mode ON + #define GC9A01A_INVOFF 0x20 ///< Display Inversion OFF + #define GC9A01A_INVON 0x21 ///< Display Inversion ON + #define GC9A01A_DISPOFF 0x28 ///< Display OFF + #define GC9A01A_DISPON 0x29 ///< Display ON + #define GC9A01A_CASET 0x2A ///< Column Address Set + #define GC9A01A_RASET 0x2B ///< Row Address Set + #define GC9A01A_RAMWR 0x2C ///< Memory Write + #define GC9A01A_PTLAR 0x30 ///< Partial Area + #define GC9A01A_VSCRDEF 0x33 ///< Vertical Scrolling Definition + #define GC9A01A_TEOFF 0x34 ///< Tearing Effect Line OFF + #define GC9A01A_TEON 0x35 ///< Tearing Effect Line ON + #define GC9A01A_MADCTL 0x36 ///< Memory Access Control + #define GC9A01A_VSCRSADD 0x37 ///< Vertical Scrolling Start Address + #define GC9A01A_IDLEOFF 0x38 ///< Idle mode OFF + #define GC9A01A_IDLEON 0x39 ///< Idle mode ON + #define GC9A01A_COLMOD 0x3A ///< Pixel Format Set + #define GC9A01A_CONTINUE 0x3C ///< Write Memory Continue + #define GC9A01A_TEARSET 0x44 ///< Set Tear Scanline + #define GC9A01A_GETLINE 0x45 ///< Get Scanline + #define GC9A01A_SETBRIGHT 0x51 ///< Write Display Brightness + #define GC9A01A_SETCTRL 0x53 ///< Write CTRL Display + #define GC9A01A1_POWER7 0xA7 ///< Power Control 7 + #define GC9A01A_TEWC 0xBA ///< Tearing effect width control + #define GC9A01A1_POWER1 0xC1 ///< Power Control 1 + #define GC9A01A1_POWER2 0xC3 ///< Power Control 2 + #define GC9A01A1_POWER3 0xC4 ///< Power Control 3 + #define GC9A01A1_POWER4 0xC9 ///< Power Control 4 + #define GC9A01A_RDID1 0xDA ///< Read ID 1 + #define GC9A01A_RDID2 0xDB ///< Read ID 2 + #define GC9A01A_RDID3 0xDC ///< Read ID 3 + #define GC9A01A_FRAMERATE 0xE8 ///< Frame rate control + #define GC9A01A_SPI2DATA 0xE9 ///< SPI 2DATA control + #define GC9A01A_INREGEN2 0xEF ///< Inter register enable 2 + #define GC9A01A_GAMMA1 0xF0 ///< Set gamma 1 + #define GC9A01A_GAMMA2 0xF1 ///< Set gamma 2 + #define GC9A01A_GAMMA3 0xF2 ///< Set gamma 3 + #define GC9A01A_GAMMA4 0xF3 ///< Set gamma 4 + #define GC9A01A_IFACE 0xF6 ///< Interface control + #define GC9A01A_INREGEN1 0xFE ///< Inter register enable 1 +#endif + +#ifdef DISPLAY_ILI9341 + #define DISPLAY_MEMORY_WRITE ILI9341_CMD_MEMORY_WRITE +#elif defined(DISPLAY_ST7735) + #define DISPLAY_MEMORY_WRITE ST77XX_MEM_WR +#elif defined(DISPLAY_GC9A01A) + #define DISPLAY_MEMORY_WRITE GC9A01A_RAMWR +#endif + +#endif /* DISPLAY_CONFIG_H_ */ \ No newline at end of file diff --git a/Firmware/Display_Default_Configurations.c b/Firmware/Display_Default_Configurations.c new file mode 100644 index 0000000..11cbdfd --- /dev/null +++ b/Firmware/Display_Default_Configurations.c @@ -0,0 +1,214 @@ +/* + * Display_Default_Configurations.c + * + * Created: Sun Jul 06 2025 15:52:12 + * Author Chris + */ +#include "Display_Default_Configurations.h" + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables +extern const unsigned char _Font_Victor_Mono_Bold_8x19[]; +extern const unsigned char _Font_Victor_Mono_Regular_6x11[]; +extern const unsigned char _Font_Victor_Mono_Regular_7x13[]; +extern const unsigned char _Font_DejaVu_Sans_Mono_10x17[]; + +Configuration_Menu_Select _Configuration_Default_Select_Menu = { + .X_Offset = 60, + .X_Indent = -4, + .Font = { _Font_Victor_Mono_Bold_8x19, _Font_Victor_Mono_Regular_7x13, _Font_Victor_Mono_Regular_6x11 }, + .Color = { DISPLAY_COLOR_WHITE, DISPLAY_COLOR_LIGHTGREY, DISPLAY_COLOR_DARKGREY } +}; + +// Configuration_Menu_Icon_Row + +Configuration_Select_YesNo _Configuration_Default_Select_YesNo = { + .Title_Font = _Font_Victor_Mono_Bold_8x19, + .Title_Color = DISPLAY_COLOR_LIGHTGREY, + .Title_Y_Center = DISPLAY_Y_CENTER-20, + + .Value_Font = _Font_DejaVu_Sans_Mono_10x17, + .Value_Center_X_Offset = 20, + .Value_Y_Center = DISPLAY_Y_CENTER+20, + .Animation_Speed = 6 +}; + +Configuration_Select_List _Configuration_Default_Select_List = { + .Font = _Font_Victor_Mono_Bold_8x19, + .List_Entry_Y_Gap = 10, + .Color_Selected = DISPLAY_COLOR_CYAN, + .Color_Not_Selected = DISPLAY_COLOR_DARKGREY +}; + +Configuration_Select_Value _Configuration_Default_Select_Value = { + .Title_Font = _Font_Victor_Mono_Bold_8x19, + .Title_Color = DISPLAY_COLOR_WHITE, + .Title_Y_Center = DISPLAY_Y_CENTER-50, + + .Value_Font = _Font_DejaVu_Sans_Mono_10x17, + .Value_Color = DISPLAY_COLOR_LIGHTGREY, + .Value_Y_Center = DISPLAY_Y_CENTER+20, + + .Show_Arc = true, + .Arc_Color = DISPLAY_COLOR_WHITE +}; + +Configuration_Select_RGB _Configuration_Default_Select_RGB = { + // Ring colors for each RGB component - vibrant but not overwhelming + .Ring_Color_Red = DISPLAY_COLOR_FROM_RGB888(255, 68, 68), // Bright red #ff4444 + .Ring_Color_Green = DISPLAY_COLOR_FROM_RGB888(68, 255, 68), // Bright green #44ff44 + .Ring_Color_Blue = DISPLAY_COLOR_FROM_RGB888(68, 68, 255), // Bright blue #4444ff + + // Geometry settings optimized for 240x240 circular display + .Center_Preview_Radius = 70, // 140px diameter color preview (leaves 50px margin) + .Progress_Ring_Radius = 100, // 200px diameter progress ring (20px from edge) + .Progress_Ring_Thickness = 8, // Substantial ring thickness for visibility + .Indicator_Radius = 8, // 16px diameter indicator dot + + // Colors for UI elements - clean monochrome scheme + .Preview_Border_Color = DISPLAY_COLOR_WHITE, // White border for contrast + .Preview_Border_Thickness = 3, // Visible but not thick border + .Indicator_Core_Color = DISPLAY_COLOR_WHITE, // White indicator core + .Indicator_Glow_Color = DISPLAY_COLOR_FROM_RGB888(200, 200, 255), // Subtle blue glow + .Background_Ring_Color = DISPLAY_COLOR_FROM_RGB888(64, 64, 64), // Dark gray background ring + .Background_Ring_Thickness = 2, // Thin background ring + + // Previous marker settings - NEW + .Previous_Marker_Color = DISPLAY_COLOR_WHITE, + .Previous_Marker_Radius = 3, + .Previous_Marker_Ring_Offset = 15, // 15 pixels inside the main ring + .Show_Previous_Markers = true, + + // Text display settings - clear hierarchy + .Component_Label_Font = _Font_Victor_Mono_Bold_8x19, // Bold for component labels (RED/GREEN/BLUE) + .Value_Font = _Font_DejaVu_Sans_Mono_10x17, // Large readable font for values + .Text_Color = DISPLAY_COLOR_WHITE, // High contrast white text + .Text_Y_Offset = 100, // 100px from bottom edge + + // Animation and interaction settings + .Smooth_Animation_Steps = 8, // Smooth but not too slow transitions + .Enable_Encoder_Acceleration = true, // Enable fast value changes + .Acceleration_Threshold = 3, // Trigger acceleration after 3 fast steps + .Acceleration_Multiplier = 5 // 5x speed during fast rotation +}; + +// Alternative configuration for smaller displays or different aesthetics +Configuration_Select_RGB _Configuration_Compact_Select_RGB = { + // More subdued colors for compact interface + .Ring_Color_Red = DISPLAY_COLOR_FROM_RGB888(220, 80, 80), // Softer red + .Ring_Color_Green = DISPLAY_COLOR_FROM_RGB888(80, 220, 80), // Softer green + .Ring_Color_Blue = DISPLAY_COLOR_FROM_RGB888(80, 80, 220), // Softer blue + + // Smaller geometry for compact displays + .Center_Preview_Radius = 50, // Smaller preview circle + .Progress_Ring_Radius = 80, // Closer to center + .Progress_Ring_Thickness = 6, // Thinner ring + .Indicator_Radius = 6, // Smaller indicator + + // Minimal UI colors + .Preview_Border_Color = DISPLAY_COLOR_LIGHTGREY, + .Preview_Border_Thickness = 2, + .Indicator_Core_Color = DISPLAY_COLOR_WHITE, + .Indicator_Glow_Color = DISPLAY_COLOR_LIGHTGREY, + .Background_Ring_Color = DISPLAY_COLOR_DARKGREY, + .Background_Ring_Thickness = 1, + + // Previous marker settings - NEW + .Previous_Marker_Color = DISPLAY_COLOR_WHITE, + .Previous_Marker_Radius = 3, + .Previous_Marker_Ring_Offset = 15, // 15 pixels inside the main ring + .Show_Previous_Markers = true, + + // Smaller fonts for compact layout + .Component_Label_Font = _Font_Victor_Mono_Regular_6x11, // Smaller label font + .Value_Font = _Font_Victor_Mono_Bold_8x19, // Medium value font + .Text_Color = DISPLAY_COLOR_LIGHTGREY, + .Text_Y_Offset = 25, + + // Faster, more responsive settings for compact interface + .Smooth_Animation_Steps = 4, // Faster transitions + .Enable_Encoder_Acceleration = true, + .Acceleration_Threshold = 2, // More sensitive acceleration + .Acceleration_Multiplier = 8 // Higher acceleration +}; + +// High contrast configuration for accessibility +Configuration_Select_RGB _Configuration_High_Contrast_Select_RGB = { + // Pure, high contrast colors + .Ring_Color_Red = DISPLAY_COLOR_RED, // Pure red + .Ring_Color_Green = DISPLAY_COLOR_GREEN, // Pure green + .Ring_Color_Blue = DISPLAY_COLOR_BLUE, // Pure blue + + // Standard geometry + .Center_Preview_Radius = 70, + .Progress_Ring_Radius = 100, + .Progress_Ring_Thickness = 10, // Thicker for better visibility + .Indicator_Radius = 10, // Larger indicator + + // High contrast UI + .Preview_Border_Color = DISPLAY_COLOR_WHITE, + .Preview_Border_Thickness = 4, // Thick border for definition + .Indicator_Core_Color = DISPLAY_COLOR_WHITE, + .Indicator_Glow_Color = DISPLAY_COLOR_WHITE, // No glow, just solid white + .Background_Ring_Color = DISPLAY_COLOR_BLACK, // Maximum contrast + .Background_Ring_Thickness = 3, + + // Previous marker settings - NEW + .Previous_Marker_Color = DISPLAY_COLOR_WHITE, + .Previous_Marker_Radius = 3, + .Previous_Marker_Ring_Offset = 15, // 15 pixels inside the main ring + .Show_Previous_Markers = true, + + // Large, clear fonts + .Component_Label_Font = _Font_DejaVu_Sans_Mono_10x17, // Larger labels + .Value_Font = _Font_Victor_Mono_Bold_8x19, // Bold values + .Text_Color = DISPLAY_COLOR_WHITE, + .Text_Y_Offset = 35, + + // Conservative animation for accessibility + .Smooth_Animation_Steps = 12, // Slower, more predictable + .Enable_Encoder_Acceleration = false, // Disable acceleration for precision + .Acceleration_Threshold = 5, + .Acceleration_Multiplier = 2 +}; + +Configuration_Entry_Indicator _Configuration_Default_Entry_Indicator_Arc = { + .Type = INDICATOR_ARC, + + .Color_Selected = DISPLAY_COLOR_WHITE, + .Color_Unselected = DISPLAY_COLOR_DARKGREY, + + .Options.Arc.Angle_Span = 120, + .Options.Arc.Thickness = 4, + .Options.Arc.Radius = 100 +}; + +Configuration_Entry_Indicator _Configuration_Default_Entry_Indicator_Dot = { + .Type = INDICATOR_DOT, + + .Color_Selected = DISPLAY_COLOR_WHITE, + .Color_Unselected = DISPLAY_COLOR_DARKGREY, + + .Options.Dot.Dot_Distance = 20, + .Options.Dot.Dot_Size = 5, + .Options.Dot.Y = 200, + .Options.Dot.Unselected_Frame_Only = true +}; + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ + + +/******************************************************************* + Internal Functions +*******************************************************************/ \ No newline at end of file diff --git a/Firmware/Display_Default_Configurations.h b/Firmware/Display_Default_Configurations.h new file mode 100644 index 0000000..c074b0d --- /dev/null +++ b/Firmware/Display_Default_Configurations.h @@ -0,0 +1,34 @@ +/* + * Display_Default_Configurations.h + * + * Created: Sun Jul 06 2025 15:51:51 + * Author Chris + */ +#ifndef DISPLAY_DEFAULT_CONFIGURATIONS_H_ +#define DISPLAY_DEFAULT_CONFIGURATIONS_H_ + +// ============================================================================================ +// Includes +#include "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes +extern Configuration_Menu_Select _Configuration_Default_Select_Menu; +extern Configuration_Select_YesNo _Configuration_Default_Select_YesNo; +extern Configuration_Select_List _Configuration_Default_Select_List; +extern Configuration_Select_Value _Configuration_Default_Select_Value; +extern Configuration_Select_RGB _Configuration_Default_Select_RGB; +extern Configuration_Select_RGB _Configuration_Compact_Select_RGB; +extern Configuration_Select_RGB _Configuration_High_Contrast_Select_RGB; +extern Configuration_Entry_Indicator _Configuration_Default_Entry_Indicator_Arc; +extern Configuration_Entry_Indicator _Configuration_Default_Entry_Indicator_Dot; + +// ============================================================================================ +// Function Declarations + +#endif /* DISPLAY_DEFAULT_CONFIGURATIONS_H_ */ diff --git a/Firmware/Display_Font.c b/Firmware/Display_Font.c new file mode 100644 index 0000000..d20829b --- /dev/null +++ b/Firmware/Display_Font.c @@ -0,0 +1,169 @@ +/* + * Display_Font.c + * + * Created: Mon Jul 19 2021 17:48:37 + * Author Chris + */ +#include "Display_Font.h" +#include "Display_Shapes.h" + +#include + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables +volatile const unsigned char* _Font; +const uint8_t FONT_DEF_LENGTH = 0; +const uint8_t FONT_DEF_FIXED_WIDTH = 2; +const uint8_t FONT_DEF_HEIGHT = 3; +const uint8_t FONT_DEF_FIRST_CHAR = 4; +const uint8_t FONT_DEF_CHAR_COUNT = 5; +const uint8_t FONT_DEF_WIDTH_TABLE = 6; + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ +void Display_Font_Init(void) +{ + _Font = NULL; +} + +void Display_Font_Set_Font(const unsigned char* font) +{ + _Font = font; +} + +uint Display_Font_Get_Font_Height(void) +{ + return _Font[FONT_DEF_HEIGHT]; +} + +uint Display_Font_Width_Char(char c) +{ + if((c < ' ') || (c > '~') || (_Font == NULL)) + { + return 0; + } + + if((_Font[FONT_DEF_LENGTH] == 0) && (_Font[FONT_DEF_LENGTH + 1] == 0)) + { + return _Font[FONT_DEF_FIXED_WIDTH]; + } + else + { + return _Font[FONT_DEF_WIDTH_TABLE + c - _Font[FONT_DEF_FIRST_CHAR]]; + } +} + +uint Display_Font_Width_String(char string[], uint8_t string_length, uint8_t char_spacing) +{ + uint Width = 0; + + // if((_Font[FONT_DEF_LENGTH] == 0) && (_Font[FONT_DEF_LENGTH + 1] == 0)) + // { + // return string_length * _Font[FONT_DEF_FIXED_WIDTH] + (string_length-1) * char_spacing; + // } + + for(uint8_t i=0;i '~') || (_Font == NULL)) { return 0; } + + int16_t Width; + int16_t Height = _Font[FONT_DEF_HEIGHT]; + int16_t H_Steps = (Height + 7 ) / 8; + uint16_t Char_Count = _Font[FONT_DEF_CHAR_COUNT]; + uint16_t Index = 0; + + c -= _Font[FONT_DEF_FIRST_CHAR]; + + if((_Font[FONT_DEF_LENGTH] == 0) && (_Font[FONT_DEF_LENGTH + 1] == 0)) + { + Width = _Font[FONT_DEF_FIXED_WIDTH]; + + // c = Character normalized to first available character + // (H_Steps * Width) = How many bytes per Character + // FONT_DEF_WIDTH_TABLE = Byte offset for the first byte in case of fixed width + Index = c * (H_Steps * Width) + FONT_DEF_WIDTH_TABLE; + } + else + { + // Read width data, to get the index + for(uint i = 0; i < c; i++) + { + Index += _Font[FONT_DEF_WIDTH_TABLE + i]; + } + + Index = Index * H_Steps + Char_Count + FONT_DEF_WIDTH_TABLE; + Width = _Font[FONT_DEF_WIDTH_TABLE + c]; + } + + // Print Character + for(int32_t h = 0; h < H_Steps; h++) + { + int32_t Page = h * Width; // Width == Character Width + for(int32_t w = 0; w < Width; w++) + { + uint8_t Data = _Font[Index + Page + w]; + + // if(Height < (h+1)*8) + // { + // Data >>= (h+1) * 8 - Height; + // } + + for(int32_t t = 0; t < 8; t++) + { + if((Data & 0x01) > 0) + { + Display_Shapes_Draw_Pixel_Safe(x + w, y + t + (h * 8), color); + } + Data >>= 1; + } + } + } + return Width; +} + +void Display_Font_Print_String(int16_t x, int16_t y, char* string, uint8_t string_length, uint8_t char_spacing, Display_Color color) +{ + uint16_t Width; + + // No idea what this piece of code was used for, but it is causing issues when adding objects outside the visible display area + // + // if(y > DISPLAY_WIDTH - _Font[FONT_DEF_HEIGHT]) + // { + // x = 0; + // y = 0; + // } + + for(uint8_t i=0;i + +#include "Display_Config.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Display_Font_Init (void); +void Display_Font_Set_Font (const unsigned char* font); +uint Display_Font_Get_Font_Height (void); +uint Display_Font_Width_Char (char c); +uint Display_Font_Width_String (char string[], uint8_t string_length, uint8_t char_spacing); +uint Display_Font_Print_Char (int16_t x, int16_t y, char c, Display_Color color); +void Display_Font_Print_String (int16_t x, int16_t y, char* string, uint8_t string_length, uint8_t char_spacing, Display_Color color); + + +#endif /* DISPLAY_FONT_H_ */ diff --git a/Firmware/Display_Image.c b/Firmware/Display_Image.c new file mode 100644 index 0000000..bba94ee --- /dev/null +++ b/Firmware/Display_Image.c @@ -0,0 +1,403 @@ +/* + * Display_Image.c + * + * Created: Thu Nov 25 2021 13:15:42 + * Author Chris + */ +#include "Display_Image.h" + +#include +#include "Display_Color.h" +#include "Display_Shapes.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables +static Display_Image_Buffer** _Current_Buffer; +static Display_Color _Transparent_Color; + +static const uint8_t IMAGE_DEF_WIDTH = 0; +static const uint8_t IMAGE_DEF_HEIGHT = 1; +static const uint8_t IMAGE_DEF_DATA_SIZE = 2; +static const uint8_t IMAGE_DEF_DATA_OFFSET = 3; + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ +void Display_Image_Init(Display_Image_Buffer** current_buffer, Display_Color transparent_color) +{ + _Current_Buffer = current_buffer; + _Transparent_Color = transparent_color; +} + +void Display_Image_Draw_Color(int16_t x, int16_t y, Image_Color* image) +{ + Display_Image_Draw_Color_Alpha(x, y, image, UINT8_MAX); +} + +void Display_Image_Draw_Color_Alpha(int16_t x, int16_t y, Image_Color* image, uint8_t alpha) +{ + if(image == NULL) { + return; + } + + // Early exit for fully transparent + if(alpha == 0) { + return; + } + + int16_t Width = image[IMAGE_DEF_WIDTH]; + int16_t Height = image[IMAGE_DEF_HEIGHT]; + + // Early exit for completely off-screen images + if(x >= DISPLAY_WIDTH || y >= DISPLAY_HEIGHT || x + Width <= 0 || y + Height <= 0) { + return; + } + + // Calculate clipping bounds + int16_t Start_X = (x < 0) ? -x : 0; + int16_t Start_Y = (y < 0) ? -y : 0; + int16_t End_X = (x + Width > DISPLAY_WIDTH) ? DISPLAY_WIDTH - x : Width; + int16_t End_Y = (y + Height > DISPLAY_HEIGHT) ? DISPLAY_HEIGHT - y : Height; + + // Optimized rendering based on alpha value + if(alpha == 255) + { + // Fully opaque - use direct copy for maximum performance + for(int16_t iy = Start_Y; iy < End_Y; iy++) + { + int16_t Screen_Y = y + iy; + uint32_t Src_Row_Offset = IMAGE_DEF_DATA_OFFSET + iy * Width; + + for(int16_t ix = Start_X; ix < End_X; ix++) + { + Display_Color Pixel_Color = image[Src_Row_Offset + ix]; + + if(Pixel_Color != _Transparent_Color) { + (*_Current_Buffer)->Dim_2[Screen_Y][x + ix] = Pixel_Color; + } + } + } + } + else + { + // Alpha blending required + for(int16_t iy = Start_Y; iy < End_Y; iy++) + { + int16_t Screen_Y = y + iy; + uint32_t Src_Row_Offset = IMAGE_DEF_DATA_OFFSET + iy * Width; + + for(int16_t ix = Start_X; ix < End_X; ix++) + { + Display_Color Src_Pixel = image[Src_Row_Offset + ix]; + + if(Src_Pixel != _Transparent_Color) { + int16_t Screen_X = x + ix; + Display_Color Dst_Pixel = (*_Current_Buffer)->Dim_2[Screen_Y][Screen_X]; + Display_Color Blended_Pixel = Display_Color_Blend_RGB565(Src_Pixel, Dst_Pixel, alpha); + (*_Current_Buffer)->Dim_2[Screen_Y][Screen_X] = Blended_Pixel; + } + } + } + } +} + +void Display_Image_Draw_Color_Scaled(int16_t x, int16_t y, Image_Color* image, float scale) +{ + Display_Image_Draw_Color_Scaled_Alpha(x, y, image, scale, 255); +} + +void Display_Image_Draw_Color_Scaled_Alpha(int16_t x, int16_t y, Image_Color* image, float scale, uint8_t alpha) +{ + if(image == NULL || scale <= 0.0f) { + return; + } + + // Early exit for fully transparent + if(alpha == 0) { + return; + } + + int16_t Original_Width = image[IMAGE_DEF_WIDTH]; + int16_t Original_Height = image[IMAGE_DEF_HEIGHT]; + + // Calculate scaled dimensions + int16_t Scaled_Width = (int16_t)(Original_Width * scale); + int16_t Scaled_Height = (int16_t)(Original_Height * scale); + + // Early exit for completely off-screen images + if(x >= DISPLAY_WIDTH || y >= DISPLAY_HEIGHT || x + Scaled_Width <= 0 || y + Scaled_Height <= 0) { + return; + } + + // Calculate clipping bounds + int16_t Start_X = (x < 0) ? -x : 0; + int16_t Start_Y = (y < 0) ? -y : 0; + int16_t End_X = (x + Scaled_Width > DISPLAY_WIDTH) ? DISPLAY_WIDTH - x : Scaled_Width; + int16_t End_Y = (y + Scaled_Height > DISPLAY_HEIGHT) ? DISPLAY_HEIGHT - y : Scaled_Height; + + // Pre-calculate fixed-point inverse scale factors + uint32_t Inv_Scale_X = (uint32_t)((65536.0f) / scale); // 16.16 fixed point + uint32_t Inv_Scale_Y = (uint32_t)((65536.0f) / scale); + + // Optimized scaling with alpha blending + if(alpha == 255) { + // Fully opaque - direct buffer access for maximum performance + for(int16_t iy = Start_Y; iy < End_Y; iy++) + { + // Calculate source Y coordinate using fixed-point math + int16_t Orig_Y = (iy * Inv_Scale_Y) >> 16; + + if(Orig_Y >= Original_Height) { + break; + } + + // Pre-calculate source row offset + uint32_t Src_Row_Offset = IMAGE_DEF_DATA_OFFSET + Orig_Y * Original_Width; + int16_t Screen_Y = y + iy; + + for(int16_t ix = Start_X; ix < End_X; ix++) + { + // Calculate source X coordinate using fixed-point math + int16_t Orig_X = (ix * Inv_Scale_X) >> 16; + + if(Orig_X >= Original_Width) { + break; + } + + Display_Color Pixel_Color = image[Src_Row_Offset + Orig_X]; + + if(Pixel_Color != _Transparent_Color) { + // Direct buffer write + (*_Current_Buffer)->Dim_2[Screen_Y][x + ix] = Pixel_Color; + } + } + } + } + else { + // Alpha blending required + for(int16_t iy = Start_Y; iy < End_Y; iy++) + { + // Calculate source Y coordinate using fixed-point math + int16_t Orig_Y = (iy * Inv_Scale_Y) >> 16; + + if(Orig_Y >= Original_Height) { + break; + } + + // Pre-calculate source row offset + uint32_t Src_Row_Offset = IMAGE_DEF_DATA_OFFSET + Orig_Y * Original_Width; + int16_t Screen_Y = y + iy; + + for(int16_t ix = Start_X; ix < End_X; ix++) + { + // Calculate source X coordinate using fixed-point math + int16_t Orig_X = (ix * Inv_Scale_X) >> 16; + + if(Orig_X >= Original_Width) { + break; + } + + Display_Color Src_Pixel = image[Src_Row_Offset + Orig_X]; + + if(Src_Pixel != _Transparent_Color) { + int16_t Screen_X = x + ix; + Display_Color Dst_Pixel = (*_Current_Buffer)->Dim_2[Screen_Y][Screen_X]; + Display_Color Blended_Pixel = Display_Color_Blend_RGB565(Src_Pixel, Dst_Pixel, alpha); + (*_Current_Buffer)->Dim_2[Screen_Y][Screen_X] = Blended_Pixel; + } + } + } + } +} + +void Display_Image_Draw_Color_Rotated(int16_t x, int16_t y, Image_Color* image, uint16_t angle) +{ + Display_Image_Draw_Color_Rotated_Alpha(x, y, image, angle, UINT8_MAX); +} + +void Display_Image_Draw_Color_Rotated_Alpha(int16_t x, int16_t y, Image_Color* image, uint16_t angle, uint8_t alpha) +{ + if(image == NULL) { + return; + } + + // Early exit for fully transparent + if(alpha == 0) { + return; + } + + int16_t Height = image[IMAGE_DEF_HEIGHT]; + int16_t Width = image[IMAGE_DEF_WIDTH]; + + // Adjust coordinates so rotation center is at (x, y) + x += (Width >> 1); + y += (Height >> 1); + + // Convert angle to radians + float Angle_Rad = (angle % 360) * M_PI / 180.0f; + float Cos_Angle = cosf(Angle_Rad); + float Sin_Angle = sinf(Angle_Rad); + + // Calculate image center + float Center_X = Width / 2.0f; + float Center_Y = Height / 2.0f; + + // Calculate bounding box of rotated image + float Corners_X[4] = {0, Width-1, Width-1, 0}; + float Corners_Y[4] = {0, 0, Height-1, Height-1}; + + int16_t Min_X = 0, Max_X = 0, Min_Y = 0, Max_Y = 0; + + for(int i = 0; i < 4; i++) { + float rx = (Corners_X[i] - Center_X) * Cos_Angle - (Corners_Y[i] - Center_Y) * Sin_Angle; + float ry = (Corners_X[i] - Center_X) * Sin_Angle + (Corners_Y[i] - Center_Y) * Cos_Angle; + + if(i == 0) { + Min_X = Max_X = (int16_t)roundf(rx); + Min_Y = Max_Y = (int16_t)roundf(ry); + } else { + if(rx < Min_X) Min_X = (int16_t)roundf(rx); + if(rx > Max_X) Max_X = (int16_t)roundf(rx); + if(ry < Min_Y) Min_Y = (int16_t)roundf(ry); + if(ry > Max_Y) Max_Y = (int16_t)roundf(ry); + } + } + + // Optimized rendering based on alpha value + if(alpha == 255) + { + // Fully opaque - use direct pixel writes for maximum performance + for(int16_t dy = Min_Y; dy <= Max_Y; dy++) + { + for(int16_t dx = Min_X; dx <= Max_X; dx++) + { + // Reverse rotation to find source pixel + float Src_X = dx * Cos_Angle + dy * Sin_Angle + Center_X; + float Src_Y = -dx * Sin_Angle + dy * Cos_Angle + Center_Y; + + // Check if source coordinates are within image bounds + int16_t ix = (int16_t)roundf(Src_X); + int16_t iy = (int16_t)roundf(Src_Y); + + if(ix >= 0 && ix < Width && iy >= 0 && iy < Height) + { + Display_Color Pixel = image[IMAGE_DEF_DATA_OFFSET + iy * Width + ix]; + if(Pixel != _Transparent_Color) { + // Calculate screen coordinates + int16_t Screen_X = x + dx; + int16_t Screen_Y = y + dy; + + // Bounds check for screen buffer + if(Screen_X >= 0 && Screen_X < DISPLAY_WIDTH && Screen_Y >= 0 && Screen_Y < DISPLAY_HEIGHT) { + (*_Current_Buffer)->Dim_2[Screen_Y][Screen_X] = Pixel; + } + } + } + } + } + } + else + { + // Alpha blending required + for(int16_t dy = Min_Y; dy <= Max_Y; dy++) + { + for(int16_t dx = Min_X; dx <= Max_X; dx++) + { + // Reverse rotation to find source pixel + float Src_X = dx * Cos_Angle + dy * Sin_Angle + Center_X; + float Src_Y = -dx * Sin_Angle + dy * Cos_Angle + Center_Y; + + // Check if source coordinates are within image bounds + int16_t ix = (int16_t)roundf(Src_X); + int16_t iy = (int16_t)roundf(Src_Y); + + if(ix >= 0 && ix < Width && iy >= 0 && iy < Height) { + Display_Color Src_Pixel = image[IMAGE_DEF_DATA_OFFSET + iy * Width + ix]; + if(Src_Pixel != _Transparent_Color) { + // Calculate screen coordinates + int16_t Screen_X = x + dx; + int16_t Screen_Y = y + dy; + + // Bounds check for screen buffer + if(Screen_X >= 0 && Screen_X < DISPLAY_WIDTH && Screen_Y >= 0 && Screen_Y < DISPLAY_HEIGHT) { + Display_Color Dst_Pixel = (*_Current_Buffer)->Dim_2[Screen_Y][Screen_X]; + Display_Color Blended_Pixel = Display_Color_Blend_RGB565(Src_Pixel, Dst_Pixel, alpha); + (*_Current_Buffer)->Dim_2[Screen_Y][Screen_X] = Blended_Pixel; + } + } + } + } + } + } +} + +void Display_Image_Draw_Alpha(int16_t x, int16_t y, Image_Alpha* image, Display_Color color) +{ + if(image == NULL) { return; } + + int16_t Height = image[IMAGE_DEF_HEIGHT]; + int16_t Width = image[IMAGE_DEF_WIDTH]; + + for(int16_t iy = 0; iy < Height ; iy++) + { + for (int16_t ix = 0; ix < Width; ix++) + { + if(image[IMAGE_DEF_DATA_OFFSET + iy * Width + ix] == UINT8_MAX) { + Display_Shapes_Draw_Pixel_Safe(x + ix, y + iy, color); + } + else if(image[IMAGE_DEF_DATA_OFFSET + iy * Width + ix] > 0) { + // This is only temporary here... + // Color needs to be scaled according to alpha value from image array + // Skipped for now, as only threshold images will be applied + Display_Shapes_Draw_Pixel_Safe(x + ix, y + iy, color); + } + } + } +} + +uint16_t Display_Image_Get_Width(Image_Color* image) +{ + if(image == NULL) { return 0; } + + return image[IMAGE_DEF_WIDTH]; +} + +uint16_t Display_Image_Get_Height(Image_Color* image) +{ + if(image == NULL) { return 0; } + + return image[IMAGE_DEF_HEIGHT]; +} + +uint16_t Display_Image_Get_Scaled_Width(Image_Color* image, float scale) +{ + if(image == NULL || scale <= 0.0f) { return 0; } + + uint16_t Original_Width = image[IMAGE_DEF_WIDTH]; + return (uint16_t)(Original_Width * scale); +} + +uint16_t Display_Image_Get_Scaled_Height(Image_Color* image, float scale) +{ + if(image == NULL || scale <= 0.0f) { return 0; } + + uint16_t Original_Height = image[IMAGE_DEF_HEIGHT]; + return (uint16_t)(Original_Height * scale); +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ + + diff --git a/Firmware/Display_Image.h b/Firmware/Display_Image.h new file mode 100644 index 0000000..194c231 --- /dev/null +++ b/Firmware/Display_Image.h @@ -0,0 +1,48 @@ +/* + * Display_Image.h + * + * Created: Thu Nov 25 2021 13:15:17 + * Author Chris + */ +#ifndef DISPLAY_IMAGE_H_ +#define DISPLAY_IMAGE_H_ + +// ============================================================================================ +// Includes +#include + +#include "Display_Config.h" +#include "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Display_Image_Init(Display_Image_Buffer** current_buffer, Display_Color transparent_color); + +void Display_Image_Draw_Color(int16_t x, int16_t y, Image_Color* image); +void Display_Image_Draw_Color_Alpha(int16_t x, int16_t y, Image_Color* image, uint8_t alpha); + +void Display_Image_Draw_Color_Scaled(int16_t x, int16_t y, Image_Color* image, float scale); +void Display_Image_Draw_Color_Scaled_Alpha(int16_t x, int16_t y, Image_Color* image, float scale, uint8_t alpha); + +void Display_Image_Draw_Color_Rotated(int16_t x, int16_t y, Image_Color* image, uint16_t angle); +void Display_Image_Draw_Color_Rotated_Alpha(int16_t x, int16_t y, Image_Color* image, uint16_t angle, uint8_t alpha); + +void Display_Image_Draw_Alpha(int16_t x, int16_t y, Image_Alpha* image, Display_Color color); + +uint16_t Display_Image_Get_Width(Image_Color* image); +uint16_t Display_Image_Get_Height(Image_Color* image); + +uint16_t Display_Image_Get_Scaled_Width(Image_Color* image, float scale); +uint16_t Display_Image_Get_Scaled_Height(Image_Color* image, float scale); + + +#endif /* DISPLAY_IMAGE_H_ */ diff --git a/Firmware/Display_Init.c b/Firmware/Display_Init.c new file mode 100644 index 0000000..1b019aa --- /dev/null +++ b/Firmware/Display_Init.c @@ -0,0 +1,240 @@ +/* + * Display_Init.c + * + * Created: Sun Mar 21 2021 12:52:01 + * Author Chris + */ +#include "Display_SPI.h" +#include "Display_Init.h" +#include "Display_Config.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ +void Display_Init_GPIOs(void) +{ + // Initialize Reset- and DC-Pins as regular GPIOs + gpio_init (DISPLAY_PIN_RESET); + gpio_set_dir (DISPLAY_PIN_RESET, GPIO_OUT); + gpio_set_slew_rate (DISPLAY_PIN_RESET, GPIO_SLEW_RATE_FAST); + DISPLAY_RESET_OFF(); + + gpio_init (DISPLAY_PIN_COMMAND); + gpio_set_dir (DISPLAY_PIN_COMMAND, GPIO_OUT); + gpio_set_slew_rate (DISPLAY_PIN_COMMAND, GPIO_SLEW_RATE_FAST); + DISPLAY_MODE_SET_DATA(); +} + +void Display_Init_Reset(void) +{ + sleep_ms(10); + DISPLAY_RESET_ON(); + sleep_ms(10); + DISPLAY_RESET_OFF(); + sleep_ms(10); + + Display_SPI_Start_Command(0x01); // Soft Reset (Valid for all Display types) + Display_SPI_Finish_Command(); + sleep_ms(150); +} + +void Display_Init_WakeUp(void) +{ + #ifdef DISPLAY_ILI9341 + Display_SPI_Start_Command(ILI9341_CMD_SLEEP_OUT); + Display_SPI_Finish_Command(); + + sleep_ms(150); + + uint8_t Data[2] = { 0, 0 }; + + Display_SPI_Start_Command(ILI9341_CMD_MEMORY_WRITE); + for(int16_t r=0 ; r +#include +#include + +#include "pico/types.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Display_Init_GPIOs(void); +void Display_Init_Reset(void); +void Display_Init_WakeUp(void); +void Display_Init_Registers(void); + + +#endif /* DISPLAY_INIT_H_ */ \ No newline at end of file diff --git a/Firmware/Display_Message_Box_Icons.c b/Firmware/Display_Message_Box_Icons.c new file mode 100644 index 0000000..6174aaf --- /dev/null +++ b/Firmware/Display_Message_Box_Icons.c @@ -0,0 +1,414 @@ +/* + * Display_Message_Box_Icons.c + * + * Created: Sat May 20 2023 11:54:15 AM + * Author: MrChros + */ +// ============================================================================================ +// Includes +#include "Display_Message_Box_Icons.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables +const unsigned char _Message_Box_Icon_Add_Circle_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Alert_Circle_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Ban_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Chatbubble_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Checkmark_Circle_Outline[] = { +24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Close_Circle_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Happy_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Information_Circle_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Sad_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +const unsigned char _Message_Box_Icon_Skull_Outline[] = { + 24, // Image Width + 24, // Image Height + 8, // Image Data Size + + // Image Data + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 255, 255, 0, 0, 255, 255, 0, 0, 0, 255, 255, 0, 255, 255, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 255, 255, 0, 0, 255, 255, 0, 0, 0, 255, 0, 0, 255, 255, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 255, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 0, 0, 255, 0, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 255, 255, 0, 255, 255, 255, 255, 255, 255, 0, 255, 255, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Interrupt Service Routines +*******************************************************************/ + + +/******************************************************************* + Functions +*******************************************************************/ +uint Display_Message_Box_Icons_Get_Icon_Width(Object_Message_Box_Icon icon) +{ + switch(icon) + { + case MESSAGE_BOX_ICON_CIRCLE_ADD: return _Message_Box_Icon_Add_Circle_Outline[0]; + case MESSAGE_BOX_ICON_CIRCLE_ALERT: return _Message_Box_Icon_Alert_Circle_Outline[0]; + case MESSAGE_BOX_ICON_CRCLE_BAN: return _Message_Box_Icon_Ban_Outline[0]; + case MESSAGE_BOX_ICON_CHATBUBBLE: return _Message_Box_Icon_Chatbubble_Outline[0]; + case MESSAGE_BOX_ICON_CIRCLE_CHECKMARK: return _Message_Box_Icon_Checkmark_Circle_Outline[0]; + case MESSAGE_BOX_ICON_CIRCLE_CLOSE: return _Message_Box_Icon_Close_Circle_Outline[0]; + case MESSAGE_BOX_ICON_CIRCLE_INFORMATION: return _Message_Box_Icon_Information_Circle_Outline[0]; + case MESSAGE_BOX_ICON_EMOJI_HAPPY: return _Message_Box_Icon_Happy_Outline[0]; + case MESSAGE_BOX_ICON_EMOJI_SAD: return _Message_Box_Icon_Sad_Outline[0]; + case MESSAGE_BOX_ICON_EMOJI_SKULL: return _Message_Box_Icon_Skull_Outline[0]; + + case MESSAGE_BOX_ICON_NONE: + default: return 0; + } +} + +uint Display_Message_Box_Icons_Get_Icon_Height(Object_Message_Box_Icon icon) +{ + switch(icon) + { + case MESSAGE_BOX_ICON_CIRCLE_ADD: return _Message_Box_Icon_Add_Circle_Outline[1]; + case MESSAGE_BOX_ICON_CIRCLE_ALERT: return _Message_Box_Icon_Alert_Circle_Outline[1]; + case MESSAGE_BOX_ICON_CRCLE_BAN: return _Message_Box_Icon_Ban_Outline[1]; + case MESSAGE_BOX_ICON_CHATBUBBLE: return _Message_Box_Icon_Chatbubble_Outline[1]; + case MESSAGE_BOX_ICON_CIRCLE_CHECKMARK: return _Message_Box_Icon_Checkmark_Circle_Outline[1]; + case MESSAGE_BOX_ICON_CIRCLE_CLOSE: return _Message_Box_Icon_Close_Circle_Outline[1]; + case MESSAGE_BOX_ICON_CIRCLE_INFORMATION: return _Message_Box_Icon_Information_Circle_Outline[1]; + case MESSAGE_BOX_ICON_EMOJI_HAPPY: return _Message_Box_Icon_Happy_Outline[1]; + case MESSAGE_BOX_ICON_EMOJI_SAD: return _Message_Box_Icon_Sad_Outline[1]; + case MESSAGE_BOX_ICON_EMOJI_SKULL: return _Message_Box_Icon_Skull_Outline[1]; + + case MESSAGE_BOX_ICON_NONE: + default: return 0; + } +} + +const unsigned char* Display_Message_Box_Icons_Get_Icon_Ptr(Object_Message_Box_Icon icon) +{ + switch(icon) + { + case MESSAGE_BOX_ICON_CIRCLE_ADD: return _Message_Box_Icon_Add_Circle_Outline; + case MESSAGE_BOX_ICON_CIRCLE_ALERT: return _Message_Box_Icon_Alert_Circle_Outline; + case MESSAGE_BOX_ICON_CRCLE_BAN: return _Message_Box_Icon_Ban_Outline; + case MESSAGE_BOX_ICON_CHATBUBBLE: return _Message_Box_Icon_Chatbubble_Outline; + case MESSAGE_BOX_ICON_CIRCLE_CHECKMARK: return _Message_Box_Icon_Checkmark_Circle_Outline; + case MESSAGE_BOX_ICON_CIRCLE_CLOSE: return _Message_Box_Icon_Close_Circle_Outline; + case MESSAGE_BOX_ICON_CIRCLE_INFORMATION: return _Message_Box_Icon_Information_Circle_Outline; + case MESSAGE_BOX_ICON_EMOJI_HAPPY: return _Message_Box_Icon_Happy_Outline; + case MESSAGE_BOX_ICON_EMOJI_SAD: return _Message_Box_Icon_Sad_Outline; + case MESSAGE_BOX_ICON_EMOJI_SKULL: return _Message_Box_Icon_Skull_Outline; + + case MESSAGE_BOX_ICON_NONE: + default: return NULL; + } +} + +/******************************************************************* + Internal Functions +*******************************************************************/ + diff --git a/Firmware/Display_Message_Box_Icons.h b/Firmware/Display_Message_Box_Icons.h new file mode 100644 index 0000000..e526b82 --- /dev/null +++ b/Firmware/Display_Message_Box_Icons.h @@ -0,0 +1,41 @@ +/* + * Display_Message_Box_Icons.h + * + * Created: Sat May 20 2023 11:54:10 AM + * Author: MrChros + */ +#ifndef DISPLAY_MESSAGE_BOX_ICONS_H_ +#define DISPLAY_MESSAGE_BOX_ICONS_H_ + +// ============================================================================================ +// Includes +#include "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables +extern const unsigned char _Message_Box_Icon_Add_Circle_Outline[]; +extern const unsigned char _Message_Box_Icon_Alert_Circle_Outline[]; +extern const unsigned char _Message_Box_Icon_Ban_Outline[]; +extern const unsigned char _Message_Box_Icon_Chatbubble_Outline[]; +extern const unsigned char _Message_Box_Icon_Checkmark_Circle_Outline[]; +extern const unsigned char _Message_Box_Icon_Close_Circle_Outline[]; +extern const unsigned char _Message_Box_Icon_Happy_Outline[]; +extern const unsigned char _Message_Box_Icon_Information_Circle_Outline[]; +extern const unsigned char _Message_Box_Icon_Sad_Outline[]; +extern const unsigned char _Message_Box_Icon_Skull_Outline[]; + + +// ============================================================================================ +// Function Declarations +uint Display_Message_Box_Icons_Get_Icon_Width(Object_Message_Box_Icon icon); +uint Display_Message_Box_Icons_Get_Icon_Height(Object_Message_Box_Icon icon); + +const unsigned char* Display_Message_Box_Icons_Get_Icon_Ptr(Object_Message_Box_Icon icon); + + +#endif /* DISPLAY_MESSAGE_BOX_ICONS_H_ */ diff --git a/Firmware/Display_Objects.c b/Firmware/Display_Objects.c new file mode 100644 index 0000000..3b63019 --- /dev/null +++ b/Firmware/Display_Objects.c @@ -0,0 +1,1465 @@ +/* + * Display_Objects.c + * + * Created: Fri Apr 02 2021 13:58:23 + * Author Chris + */ +#include "Display.h" +#include "Display_Font.h" +#include "Display_Image.h" +#include "Display_Objects.h" +#include "Display_Message_Box_Icons.h" + +#include +#include + + +// ============================================================================================ +// Defines +#define DEG2RAD (float)(M_PI / 180) + + +// ============================================================================================ +// Variables +volatile Display_Color _Background_Color; + +struct +{ + Display_Object *Array; + size_t Used; + size_t Size; +} _Objects; + +struct +{ + Style *Array; + size_t Used; + size_t Size; +} _Styles; + +struct +{ + Animation *Array; + size_t Used; + size_t Size; +} _Animations; + +struct +{ + Font *Array; + size_t Used; + size_t Size; +} _Fonts; + + +// ============================================================================================ +// Function Declarations +Object_ID Display_Objects_Add(Object_Type type, Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, void *data, Style_ID style_id, Animation_ID animation_id); +Style* Display_Objects_Style_From_ID(Style_ID style_id); +Animation* Display_Objects_Animation_From_ID(Animation_ID animation_id); +Font* Display_Objects_Font_From_ID(Font_ID font_id); + +void Display_Objects_Update_Coordinates_Offset_And_Dimension(Display_Object *object, Anchor_Point anchor_point, Coordinates_Type coordinates_type); +void Display_Objects_Convert_Coordinates(Coordinates_Type coordinates_type, Coordinates* coordinates); +Dimension Display_Objects_Get_Content_Size(Display_Object *object); +Dimension Display_Objects_Get_Content_Size_From_Shape(Display_Object *object); + + +/******************************************************************* + Functions +*******************************************************************/ +void Display_Objects_Init(Display_Color background_color) +{ + _Objects.Array = NULL; + _Objects.Used = _Objects.Size = 0; + + _Styles.Array = NULL; + _Styles.Used = _Styles.Size = 0; + + Display_Objects_Background_Color_Set(background_color); +} + +void Display_Objects_Background_Color_Set(Display_Color color) +{ + _Background_Color = color; +} + +Display_Color Display_Objects_Background_Color_Get(void) +{ + return _Background_Color; +} + +void Display_Objects_Clear(void) +{ + Object_Value_Bar_Arc *VA; + Object_Menu_Ring *MR; + Object_Canvas *C; + + for (uint i = 0; i < _Objects.Size; i++) + { + Display_Object* O = Display_Objects_Get_By_ID(i); + switch (O->Type) + { + case FLOAT: + free((Object_Float*)(O->Data)); + break; + case INTEGER: + free((Object_Integer*)(O->Data)); + break; + case TEXT: + free((Object_Text*)(O->Data)); + break; + case VALUE_BAR_RECT: + free((Object_Value_Bar_Rect*)(O->Data)); + break; + case VALUE_BAR_ARC: + VA = (Object_Value_Bar_Arc*)(O->Data); + free((Object_Shape*)(VA->Arc)); + free(VA); + break; + case GRAPH: + free((Object_Graph*)(O->Data)); + break; + case BUTTON: + free((Object_Button*)(O->Data)); + break; + case IMAGE: + free((Object_Image_Color*)(O->Data)); + break; + case BOOLEAN: + free((Object_Bool*)(O->Data)); + break; + case SHAPE: + free((Object_Shape*)(O->Data)); + break; + case CANVAS: + C = (Object_Canvas*)(O->Data); + free(C->Data); + free(C); + case MESSAGE_BOX: + free((Object_Message_Box*)(O->Data)); + break; + case MENU_SELECT: + free((Object_Menu_Select*)(O->Data)); + break; + case MENU_ICON_ROW: + free((Object_Menu_Icon_Row*)(O->Data)); + break; + case MENU_RING: + MR = (Object_Menu_Ring*)(O->Data); + free(MR->Items); + free(MR->Item_Scales); + free(MR->Item_Glow_Intensity); + if (MR->Appear_Animation != NULL) { + free(MR->Appear_Animation); + } + free(MR); + break; + case SELECT_YESNO: + free((Object_Select_YesNo*)(O->Data)); + break; + case SELECT_LIST: + free((Object_Select_List*)(O->Data)); + break; + case SELECT_VALUE: + free((Object_Select_Value*)(O->Data)); + break; + case SELECT_RGB: + free((Object_Select_RGB*)(O->Data)); + break; + + default: + break; + } + O->Data = NULL; + + if (O->Animation_Status != NULL) + { + free(O->Animation_Status); + O->Animation_Status = NULL; + } + } + + free(_Objects.Array); + _Objects.Array = NULL; + _Objects.Used = _Objects.Size = 0; + + free(_Styles.Array); + _Styles.Array = NULL; + _Styles.Used = _Styles.Size = 0; + + free(_Animations.Array); + _Animations.Array = NULL; + _Animations.Used = _Animations.Size = 0; + + free(_Fonts.Array); + _Fonts.Array = NULL; + _Fonts.Used = _Fonts.Size = 0; + + Display_Unselect_Object(); +} + +Style_ID Display_Objects_Add_Style(Display_Color background_color, Display_Color border_color, uint border_thickness, uint border_radius, uint padding_top, uint padding_right, uint padding_bottom, uint padding_left, float width_height_ratio) +{ + Style Style; + Style.Background_Color = background_color; + Style.Border_Color = border_color; + Style.Border_Thickness = border_thickness; + Style.Border_Radius = border_radius; + Style.Padding[PADDING_TOP] = padding_top; + Style.Padding[PADDING_LEFT] = padding_left; + Style.Padding[PADDING_BOTTOM] = padding_bottom; + Style.Padding[PADDING_RIGHT] = padding_right; + Style.Width_Height_Ratio = width_height_ratio; + + if (_Styles.Used == _Styles.Size) + { + _Styles.Size++; + _Styles.Array = realloc(_Styles.Array, _Styles.Size * sizeof(Style)); + } + + _Styles.Array[_Styles.Used++] = Style; + + return (Style_ID)(_Styles.Used - 1); +} + +Animation_ID Display_Objects_Add_Animation(int offset_x, int offset_y, uint tick_delay, uint tick_duration, Animation_Order start_condition) +{ + Animation Animation; + Animation.Offset.X = offset_x; + Animation.Offset.Y = offset_y; + Animation.Tick_Delay = tick_delay; + Animation.Tick_Duration = tick_duration; + Animation.Animation_Start = start_condition; + + if (_Animations.Used == _Animations.Size) + { + _Animations.Size++; + _Animations.Array = realloc(_Animations.Array, _Animations.Size * sizeof(Animation)); + } + + _Animations.Array[_Animations.Used++] = Animation; + + return (Animation_ID)(_Animations.Used - 1); +} + +Font_ID Display_Objects_Add_Font(const unsigned char *font, uint8_t character_spacing) +{ + Font Font; + Font.Font = font; + Font.Character_Spacing = character_spacing; + + if (_Fonts.Used == _Fonts.Size) + { + _Fonts.Size++; + _Fonts.Array = realloc(_Fonts.Array, _Fonts.Size * sizeof(Font)); + } + + _Fonts.Array[_Fonts.Used++] = Font; + + return (Font_ID)(_Fonts.Used - 1); +} + +size_t Display_Objects_Count(void) +{ + return _Objects.Size; +} + +Display_Object *Display_Objects_Get_By_ID(Object_ID id) +{ + if (id < _Objects.Size) + { + return &(_Objects.Array[id]); + } + + return NULL; +} + +size_t Display_Objects_Get_Count_Canvas(void) +{ + size_t Canvas_Count = 0; + + for(uint i=0;iType == CANVAS) + { + Canvas_Count++; + } + } + + return Canvas_Count; +} + +Object_ID Display_Objects_Get_ID_From_Canvas_Number(uint canvas_number) +{ + for(uint i=0;iType == CANVAS) + { + if(canvas_number == 0) + { + return i; + } + else + { + canvas_number--; + } + } + } + + return -1; +} + +Object_ID Display_Objects_Add_Float(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, float *value, char *format, Font_ID font, Display_Color color, Style_ID style_id, Animation_ID animation_id) +{ + Object_Float *Number = malloc(sizeof(Object_Float)); + Number->Font = Display_Objects_Font_From_ID(font); + Number->Color = color; + Number->Value = value; + sprintf(Number->Format, "%s", format); + + return Display_Objects_Add(FLOAT, anchor_point, coordinates_type, x, y, selectable, (void *)Number, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Integer(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, int *value, char *format, Font_ID font, Display_Color color, Style_ID style_id, Animation_ID animation_id) +{ + Object_Integer *Number = malloc(sizeof(Object_Integer)); + Number->Font = Display_Objects_Font_From_ID(font); + Number->Color = color; + Number->Value = value; + sprintf(Number->Format, "%s", format); + + return Display_Objects_Add(INTEGER, anchor_point, coordinates_type, x, y, selectable, (void *)Number, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Text(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, char *text, Font_ID font, Display_Color color, Style_ID style_id, Animation_ID animation_id) +{ + Object_Text *Text = malloc(sizeof(Object_Text)); + Text->Font = Display_Objects_Font_From_ID(font); + Text->Color = color; + Text->Length = sprintf(Text->Text, "%s", text); + + return Display_Objects_Add(TEXT, anchor_point, coordinates_type, x, y, selectable, (void *)Text, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Value_Bar_Rect(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, uint32_t *value, uint32_t max, uint32_t min, Orientation orientation, Display_Color color, uint32_t width, uint32_t height, Style_ID style_id, Animation_ID animation_id) +{ + Object_Value_Bar_Rect *Bar = malloc(sizeof(Object_Value_Bar_Rect)); + Bar->Value = value; + Bar->Max = max; + Bar->Min = min; + Bar->Orientation = orientation; + Bar->Color = color; + Bar->Dimension.Width = width; + Bar->Dimension.Height = height; + + return Display_Objects_Add(VALUE_BAR_RECT, anchor_point, coordinates_type, x, y, selectable, (void *)Bar, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Value_Bar_Arc(Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, uint32_t* value, uint32_t max, uint32_t min, uint32_t delta_inc, uint32_t delta_dec, Display_Color color, uint16_t radius, uint16_t thickness, uint16_t steps, int16_t angle_start, int16_t angle_end, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Arc = malloc(sizeof(Object_Shape)); + Arc->Type = ARC; + Arc->Color = color; + Arc->Dimension.Width = 0; + Arc->Dimension.Height = 0; + Arc->Radius_Start = radius; + Arc->Radius_End = radius; + Arc->Thickness = thickness; + Arc->Draw_Steps = steps; + Arc->Angle_Start = angle_start; + Arc->Angle_End = angle_end; + + Object_Value_Bar_Arc *Value_Bar = malloc(sizeof(Object_Value_Bar_Arc)); + Value_Bar->Value = value; + Value_Bar->Max = max; + Value_Bar->Min = min; + Value_Bar->Current = *value; + Value_Bar->Delta_Inc = delta_inc; + Value_Bar->Delta_Dec = delta_dec; + Value_Bar->Arc = Arc; + Value_Bar->Angle_End = angle_end; + + return Display_Objects_Add(VALUE_BAR_ARC, LEFT_TOP, coordinates_type, x, y, selectable, (void *)Value_Bar, style_id, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Graph(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, uint16_t *data, uint16_t data_length, uint max, uint min, Display_Color color, uint height, Style_ID style_id, Animation_ID animation_id) +{ + Object_Graph *Graph = malloc(sizeof(Object_Graph)); + Graph->Data = data; + Graph->Data_Length = data_length; + Graph->Max = max; + Graph->Min = min; + Graph->Color = color; + Graph->Dimension.Width = data_length; + Graph->Dimension.Height = height; + + return Display_Objects_Add(GRAPH, anchor_point, coordinates_type, x, y, selectable, (void *)Graph, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Button(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, char *text, Font_ID font, uint return_value, Display_Color color, uint width, uint height, Style_ID style_id, Animation_ID animation_id) +{ + Object_Button *Button = malloc(sizeof(Object_Button)); + Button->Font = Display_Objects_Font_From_ID(font); + Button->Return_Value = return_value; + Button->Color = color; + Button->Length = sprintf(Button->Text, "%s", text); + Button->Dimension.Height = height; + Button->Dimension.Width = width; + + return Display_Objects_Add(BUTTON, anchor_point, coordinates_type, x, y, selectable, (void *)Button, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Image(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Image_Color* image, uint16_t Rotation_Angle, Style_ID style_id, Animation_ID animation_id) +{ + Object_Image_Color *Image = malloc(sizeof(Object_Image_Color)); + + Image->Image = image; + Image->Rotation_Angle = Rotation_Angle; + Image->Alpha = UINT8_MAX; + + return Display_Objects_Add(IMAGE, anchor_point, coordinates_type, x, y, selectable, (void *)Image, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Bool(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, bool* value, char* text_true, Display_Color color_true, char* text_false, Display_Color color_false, Font_ID font , Style_ID style_id, Animation_ID animation_id) +{ + Object_Bool *Bool = malloc(sizeof(Object_Bool)); + Bool->Value = value; + Bool->Length_True = sprintf(Bool->Text_True , "%s", text_true); + Bool->Length_False = sprintf(Bool->Text_False , "%s", text_false); + Bool->Color_True = color_true; + Bool->Color_False = color_false; + Bool->Font = Display_Objects_Font_From_ID(font); + + return Display_Objects_Add(BOOLEAN, anchor_point, coordinates_type, x, y, selectable, (void *)Bool, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Rectangle_Filled(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = RECTANGLE_FILLED; + Shape->Color = color; + Shape->Dimension.Width = width; + Shape->Dimension.Height = height; + Shape->Radius_Start = 0; + Shape->Radius_End = 0; + Shape->Thickness = 0; + Shape->Draw_Steps = 0; + Shape->Angle_Start = 0; + Shape->Angle_End = 0; + + return Display_Objects_Add(SHAPE, anchor_point, coordinates_type, x, y, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Rectangle_Frame(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height, uint16_t border_thickness, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = RECTANGLE_FRAME; + Shape->Color = color; + Shape->Dimension.Width = width; + Shape->Dimension.Height = height; + Shape->Radius_Start = 0; + Shape->Radius_End = 0; + Shape->Thickness = border_thickness; + Shape->Draw_Steps = 0; + Shape->Angle_Start = 0; + Shape->Angle_End = 0; + + return Display_Objects_Add(SHAPE, anchor_point, coordinates_type, x, y, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Rounded_Rectangle_Filled(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height, uint16_t radius, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = ROUNDED_RECTANGLE_FILLED; + Shape->Color = color; + Shape->Dimension.Width = width; + Shape->Dimension.Height = height; + Shape->Radius_Start = radius; + Shape->Radius_End = radius; + Shape->Thickness = 0; + Shape->Draw_Steps = 0; + Shape->Angle_Start = 0; + Shape->Angle_End = 0; + + return Display_Objects_Add(SHAPE, anchor_point, coordinates_type, x, y, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Rounded_Rectangle_Frame(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height, uint16_t radius, uint16_t border_thickness, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = ROUNDED_RECTANGLE_FRAME; + Shape->Color = color; + Shape->Dimension.Width = width; + Shape->Dimension.Height = height; + Shape->Radius_Start = radius; + Shape->Radius_End = radius; + Shape->Thickness = border_thickness; + Shape->Draw_Steps = 0; + Shape->Angle_Start = 0; + Shape->Angle_End = 0; + + return Display_Objects_Add(SHAPE, anchor_point, coordinates_type, x, y, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Circle_Frame(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint16_t radius, uint16_t thickness, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = CIRCLE; + Shape->Color = color; + Shape->Dimension.Width = 0; + Shape->Dimension.Height = 0; + Shape->Radius_Start = radius; + Shape->Radius_End = radius; + Shape->Thickness = thickness; + Shape->Draw_Steps = 0; + Shape->Angle_Start = 0; + Shape->Angle_End = 0; + + Coordinates Coordinates_In_Px = { .X = x, .Y = y }; + Display_Objects_Convert_Coordinates(coordinates_type, &Coordinates_In_Px); + + return Display_Objects_Add(SHAPE, anchor_point, BOTH_IN_PIXEL, Coordinates_In_Px.X + radius, Coordinates_In_Px.Y + radius, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Arc_Frame(Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint16_t radius, uint16_t thickness, uint16_t steps, int16_t angle_start, int16_t angle_end, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = ARC; + Shape->Color = color; + Shape->Dimension.Width = 0; + Shape->Dimension.Height = 0; + Shape->Radius_Start = radius; + Shape->Radius_End = radius; + Shape->Thickness = thickness; + Shape->Draw_Steps = steps; + Shape->Angle_Start = angle_start; + Shape->Angle_End = angle_end; + + return Display_Objects_Add(SHAPE, LEFT_TOP, coordinates_type, x, y, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Dispaly_Objects_Add_Line_XY(Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, int16_t x2, int16_t y2, uint16_t thickness, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = LINE_XY; + Shape->Color = color; + Shape->Dimension.Width = 0; + Shape->Dimension.Height = 0; + Shape->Radius_Start = 0; + Shape->Radius_End = 0; + Shape->Thickness = thickness; + Shape->Draw_Steps = 0; + Shape->Angle_Start = x2; + Shape->Angle_End = y2; + + return Display_Objects_Add(SHAPE, LEFT_TOP, coordinates_type, x, y, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Dispaly_Objects_Add_Line_Rad(Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint16_t radius_start, uint16_t radius_end, uint16_t thickness, int16_t angle, Style_ID style_id, Animation_ID animation_id) +{ + Object_Shape *Shape = malloc(sizeof(Object_Shape)); + Shape->Type = LINE_RAD; + Shape->Color = color; + Shape->Dimension.Width = 0; + Shape->Dimension.Height = 0; + Shape->Radius_Start = radius_start; + Shape->Radius_End = radius_end; + Shape->Thickness = thickness; + Shape->Draw_Steps = 0; + Shape->Angle_Start = angle; + Shape->Angle_End = 0; + + return Display_Objects_Add(SHAPE, LEFT_TOP, coordinates_type, x, y, selectable, (void *)Shape, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Canvas(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint width, uint height, Style_ID style_id, Animation_ID animation_id) +{ + Object_Canvas *Canvas = malloc(sizeof(Object_Canvas)); + Canvas->Dimension.Width = width; + Canvas->Dimension.Height = height; + Canvas->Data = (uint16_t*) malloc(width * height * sizeof(uint16_t)); + + for(uint y=0;yData[y * width + x] = color; + } + } + + return Display_Objects_Add(CANVAS, anchor_point, coordinates_type, x, y, selectable, (void *)Canvas, style_id, animation_id); +} + +Object_ID Display_Objects_Add_Message_Box(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, char* text, Font_ID font, Object_Message_Box_Icon icon, Display_Color color, Style_ID style_id) +{ + Object_Message_Box *Message_Box = malloc(sizeof(Object_Message_Box)); + Message_Box->Length = sprintf(Message_Box->Text, "%s", text); + Message_Box->Font = Display_Objects_Font_From_ID(font); + Message_Box->Color = color; + Message_Box->Icon = icon; + Message_Box->Show_Ticks_Left = 0; + + return Display_Objects_Add(MESSAGE_BOX, anchor_point, coordinates_type, x, y, NOT_SELECTABLE, (void *)Message_Box, style_id, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Menu_Select(char* menu_titles, uint32_t menu_entry_count, uint32_t title_char_length, uint32_t* selected_entry, Configuration_Menu_Select* config) +{ + Object_Menu_Select* Menu_Select = malloc(sizeof(Object_Menu_Select)); + Menu_Select->Menu_Titles = menu_titles; + Menu_Select->Menu_Entry_Count = menu_entry_count; + Menu_Select->Title_Char_Length = title_char_length; + Menu_Select->Selected_Entry = selected_entry; + Menu_Select->Config = config; + + return Display_Objects_Add(MENU_SELECT, LEFT_TOP, BOTH_IN_PIXEL, 0, 0, NOT_SELECTABLE, (void *)Menu_Select, NO_STYLE, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Menu_Icon_Row(Icon_Row_Item* items, uint32_t item_count, uint32_t* selected_item, Configuration_Menu_Icon_Row* config) +{ + Object_Menu_Icon_Row* Icon_Row = malloc(sizeof(Object_Menu_Icon_Row)); + Icon_Row->Items = items; + Icon_Row->Item_Count = item_count; + Icon_Row->Selected_Item = selected_item; + Icon_Row->Config = config; + + return Display_Objects_Add(MENU_ICON_ROW, LEFT_TOP, BOTH_IN_PIXEL, 0, 0, NOT_SELECTABLE, (void *)Icon_Row, NO_STYLE, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Menu_Ring(Menu_Ring_Item_Config* items, uint32_t item_count, uint32_t* selected_item, Configuration_Menu_Ring* config) +{ + if (item_count == 0 || item_count > 16) { // Reasonable limits + return -1; // Invalid item count + } + + Object_Menu_Ring* Menu_Ring = malloc(sizeof(Object_Menu_Ring)); + + // Allocate dynamic arrays + Menu_Ring->Items = malloc(sizeof(Menu_Ring_Item_Config) * item_count); + Menu_Ring->Item_Scales = malloc(sizeof(float) * item_count); + Menu_Ring->Item_Glow_Intensity = malloc(sizeof(uint8_t) * item_count); + + // Copy item configurations and initialize states + for (uint32_t i = 0; i < item_count; i++) { + Menu_Ring->Items[i] = items[i]; + Menu_Ring->Item_Scales[i] = (i == *selected_item) ? config->Selection_Scale : 1.0f; + Menu_Ring->Item_Glow_Intensity[i] = (i == *selected_item) ? 255 : 0; + } + + Menu_Ring->Item_Count = item_count; + Menu_Ring->Selected_Item = selected_item; + Menu_Ring->Config = config; + + // Initialize animation state + Menu_Ring->Animation_Counter = 0; + Menu_Ring->Idle_Rotation_Angle = 0.0f; + Menu_Ring->Selection_Animation_Progress = 0; + Menu_Ring->Animation_Target = *selected_item; + + // Initialize appear animation + Menu_Ring->Appear_Animation = malloc(sizeof(Menu_Ring_Appear_Animation)); + Menu_Ring->Appear_Animation->State = MENU_RING_APPEAR_STATE_IDLE; + Menu_Ring->Appear_Animation->Ring_Draw_Angle = 0.0f; + Menu_Ring->Appear_Animation->Center_Scale = 0.0f; + Menu_Ring->Appear_Animation->Ring_Draw_Counter = 0; + Menu_Ring->Appear_Animation->Center_Grow_Counter = 0; + Menu_Ring->Appear_Animation->Current_Item_Appearing = 0; + Menu_Ring->Appear_Animation->Current_Item_Scale = 0.0f; + Menu_Ring->Appear_Animation->Item_Pop_Counter = 0; + Menu_Ring->Appear_Animation->Item_Delay_Counter = 0; + + // Calculate animation timing + Menu_Ring->Appear_Animation->Total_Ring_Draw_Frames = 360 / MENU_RING_APPEAR_CIRCLE_DRAW_SPEED; + Menu_Ring->Appear_Animation->Total_Center_Grow_Frames = MENU_RING_APPEAR_CIRCLE_GROW_SPEED; + Menu_Ring->Appear_Animation->Total_Item_Pop_Frames = MENU_RING_APPEAR_ITEM_POP_SPEED; + Menu_Ring->Appear_Animation->Total_Item_Delay_Frames = MENU_RING_APPEAR_ITEM_DELAY; + + Menu_Ring->Appear_Animation_Active = false; + + return Display_Objects_Add(MENU_RING, LEFT_TOP, BOTH_IN_PIXEL, 0, 0, SELECTABLE, (void *)Menu_Ring, NO_STYLE, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Select_YesNo(char* title, uint32_t title_length, bool* value, Configuration_Select_YesNo* config) +{ + Object_Select_YesNo* Select_YesNo = malloc(sizeof(Object_Select_YesNo)); + Select_YesNo->Title = title; + Select_YesNo->Title_Length = title_length; + Select_YesNo->Value = value; + Select_YesNo->Config = config; + + return Display_Objects_Add(SELECT_YESNO, LEFT_TOP, BOTH_IN_PIXEL, 0, 0, NOT_SELECTABLE, (void *)Select_YesNo, NO_STYLE, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Select_List(char* list_titles, uint32_t list_entry_count, uint32_t list_char_length, uint32_t* selected_entry, Configuration_Select_List* config) +{ + Object_Select_List* Select_List = malloc(sizeof(Object_Select_List)); + Select_List->List_Titles = list_titles; + Select_List->List_Entry_Count = list_entry_count; + Select_List->List_Char_Length = list_char_length; + Select_List->Selected_Entry = selected_entry; + Select_List->Config = config; + + return Display_Objects_Add(SELECT_LIST, LEFT_TOP, BOTH_IN_PIXEL, 0, 0, NOT_SELECTABLE, (void *)Select_List, NO_STYLE, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Select_Value(char* title, uint32_t title_length, int32_t* value, int32_t max, int32_t min, char* format, Configuration_Select_Value* config) +{ + Object_Select_Value* Select_Value = malloc(sizeof(Object_Select_Value)); + Select_Value->Title = title; + Select_Value->Title_Length = title_length; + Select_Value->Value = value; + Select_Value->Max = max; + Select_Value->Min = min; + sprintf(Select_Value->Format, "%s", format); + Select_Value->Config = config; + + return Display_Objects_Add(SELECT_VALUE, LEFT_TOP, BOTH_IN_PIXEL, 0, 0, NOT_SELECTABLE, (void *)Select_Value, NO_STYLE, NO_ANIMATION); +} + +Object_ID Display_Objects_Add_Select_RGB(RGB_Color* color_value, uint8_t* current_component, Configuration_Select_RGB* config) +{ + if (color_value == NULL || config == NULL) { + return -1; // Invalid parameters + } + + // Allocate memory for the RGB selector object + Object_Select_RGB* Select_RGB = malloc(sizeof(Object_Select_RGB)); + if (Select_RGB == NULL) { + return -1; // Memory allocation failed + } + + // Initialize RGB value pointer + Select_RGB->Color_Value = color_value; + + // Set current state + Select_RGB->Current_Component = current_component; + + // Initialize component labels + sprintf((char*)Select_RGB->Component_Labels[0], "RED"); + sprintf((char*)Select_RGB->Component_Labels[1], "GREEN"); + sprintf((char*)Select_RGB->Component_Labels[2], "BLUE"); + + // Initialize animation state + Select_RGB->Target_Value = Select_RGB->Color_Value->Array[*current_component]; // Array is R,G,B,A so: R=Array[0], G=Array[1], B=Array[2] + Select_RGB->Display_Value = Select_RGB->Target_Value; + Select_RGB->Animation_Counter = 0; + + // UI Geometry + Select_RGB->Progress_Start_Angle = 270.0f; // 12 o'clock position + + // Store configuration reference + Select_RGB->Config = config; + + // Add to display objects system + // RGB selector is typically a full-screen interface, so use center positioning + return Display_Objects_Add( + SELECT_RGB, // Object type + LEFT_TOP, // Anchor point + BOTH_IN_PIXEL, // Coordinate type + 0, //Select_RGB->Center_Position.X, // X position + 0, //Select_RGB->Center_Position.Y, // Y position + SELECTABLE, // Not selectable for encoder input + (void*)Select_RGB, // Object data + NO_STYLE, // No style needed (custom rendering) + NO_ANIMATION // No standard animation (custom smooth transitions) + ); +} + +Object_ID Display_Objects_Add_Entry_Indicator(uint32_t entry_count, int32_t* entry_value, Configuration_Entry_Indicator* config) +{ + Object_Entry_Indicator* Entry_Indicator = malloc(sizeof(Object_Entry_Indicator)); + Entry_Indicator->Entry_Count = entry_count; + Entry_Indicator->Entry_Value = entry_value; + Entry_Indicator->Config = config; + + return Display_Objects_Add(ENTRY_INDICATOR, LEFT_TOP, BOTH_IN_PIXEL, 0, 0, NOT_SELECTABLE, (void *)Entry_Indicator, NO_STYLE, NO_ANIMATION); +} + +void Display_Objects_Update_Coordinates(Object_ID id, Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + Object->Coordinates.X = x; + Object->Coordinates.Y = y; + Display_Objects_Update_Coordinates_Offset_And_Dimension(Object, anchor_point, coordinates_type); +} + +void Display_Objects_Update_Enabled(Object_ID id, bool is_enabled) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + Object->Enabled = is_enabled; +} + +void Display_Objects_Update_Color(Object_ID id, Display_Color color) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + switch(Object->Type) + { + case FLOAT: + ((Object_Float*)(Object->Data))->Color = color; + break; + + case INTEGER: + ((Object_Integer*)(Object->Data))->Color = color; + break; + + case TEXT: + ((Object_Text*)(Object->Data))->Color = color; + break; + + case VALUE_BAR_RECT: + ((Object_Value_Bar_Rect*)(Object->Data))->Color = color; + break; + + case BUTTON: + ((Object_Button*)(Object->Data))->Color = color; + break; + + case SHAPE: + ((Object_Shape*)(Object->Data))->Color = color; + break; + + default: + break; + } +} + +void Display_Objects_Update_Text(Object_ID id, char* text) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + Object_Text* Text; + Object_Button* Button; + + switch(Object->Type) + { + case TEXT: + Text = (Object_Text*)(Object->Data); + Text->Length = sprintf(Text->Text, "%s", text); + break; + + case BUTTON: + Button = (Object_Button*)(Object->Data); + Button->Length = sprintf(Button->Text, "%s", text); + break; + + default: + break; + } +} + +void Display_Objects_Update_Image(Object_ID id, Image_Color* new_image) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL || new_image == NULL) { + return; + } + + if(Object->Type != IMAGE) { + return; + } + + Object_Image_Color* IM = (Object_Image_Color*)(Object->Data); + + IM->Image = new_image; +} + +void Display_Objects_Update_Alpha(Object_ID id, uint8_t new_alpha) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + if(Object->Type != IMAGE) { + return; + } + + Object_Image_Color* IM = (Object_Image_Color*)(Object->Data); + + IM->Alpha = new_alpha; +} + +void Display_Objects_Update_Max_Min(Object_ID id, uint max, uint min) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + switch(Object->Type) + { + case VALUE_BAR_RECT: + ((Object_Value_Bar_Rect*)Object->Data)->Max = max; + ((Object_Value_Bar_Rect*)Object->Data)->Min = min; + break; + + case GRAPH: + ((Object_Graph*)Object->Data)->Max = max; + ((Object_Graph*)Object->Data)->Min = min; + break; + + default: + break; + } +} + +int Display_Objects_Update_Pixel(Object_ID id, int16_t x, int16_t y, Display_Color color) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return OBJECT_NOT_FOUND; + } + + Object_Canvas* C; + + switch(Object->Type) + { + case CANVAS: + C = (Object_Canvas*)(Object->Data); + + if(x<0 || x>=C->Dimension.Width) { return X_OUT_OF_RANGE; } + if(y<0 || y>=C->Dimension.Height) { return Y_OUT_OF_RANGE; } + + C->Data[y * C->Dimension.Width + x] = color; + + return CANVAS_UPDATE_OK; + + default: + break; + } + + return OBJECT_WRONG_TYPE; +} + +void Display_Objects_Show_Message_Box(Object_ID id, uint32_t ticks) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + if (Object->Type != MESSAGE_BOX) { + return; + } + + Object_Message_Box* M = (Object_Message_Box*)(Object->Data); + M->Show_Ticks_Max = ticks; + M->Show_Ticks_Left = ticks; +} + +void Display_Objects_Update_Angles_Rel(Object_ID id, int16_t angle_delta) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + if (Object->Type == SHAPE) + { + Object_Shape* S = (Object_Shape*)(Object->Data); + if(S->Type != ARC && S->Type != LINE_RAD) { + return; + } + + S->Angle_Start += angle_delta; + S->Angle_Start %= 360; + if(S->Angle_Start < 0) { + S->Angle_Start += 360; + } + + S->Angle_End += angle_delta; + S->Angle_End %= 360; + if(S->Angle_End < 0) { + S->Angle_End += 360; + } + } + else if(Object->Type == IMAGE) { + Object_Image_Color* IM = (Object_Image_Color*)(Object->Data); + IM->Rotation_Angle += angle_delta; + + IM->Rotation_Angle %= 360; + if(IM->Rotation_Angle < 0) { + IM->Rotation_Angle += 360; + } + } +} + +void Display_Objects_Update_Angle_Start(Object_ID id, int16_t angle) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + if (Object->Type != SHAPE) { + return; + } + + Object_Shape* S = (Object_Shape*)(Object->Data); + if(S->Type != ARC) { + return; + } + + S->Angle_Start = angle; + S->Angle_Start %= 360; + if(S->Angle_Start < 0) { + S->Angle_Start += 360; + } +} + +void Display_Objects_Update_Angle_End(Object_ID id, int16_t angle) +{ + Display_Object* Object = Display_Objects_Get_By_ID(id); + + if(Object == NULL) { + return; + } + + if (Object->Type != SHAPE) { + return; + } + + Object_Shape* S = (Object_Shape*)(Object->Data); + if(S->Type != ARC) { + return; + } + + S->Angle_End = angle; + S->Angle_End %= 360; + if(S->Angle_End < 0) { + S->Angle_End += 360; + } +} + +void Display_Objects_Menu_Ring_Start_Appear_Animation(Object_ID menu_ring_id) +{ + Display_Object* Object = Display_Objects_Get_By_ID(menu_ring_id); + if (Object == NULL || Object->Type != MENU_RING) { + return; + } + + Object_Menu_Ring* Menu_Ring = (Object_Menu_Ring*)Object->Data; + if(Menu_Ring->Config == NULL) { + return; + } + + Menu_Ring->Config->Enable_Appear_Animation = true; + + if (Menu_Ring->Appear_Animation != NULL) { + // Reset animation state + Menu_Ring->Appear_Animation->State = MENU_RING_APPEAR_STATE_DRAWING_RING; + Menu_Ring->Appear_Animation->Ring_Draw_Angle = 0.0f; + Menu_Ring->Appear_Animation->Center_Scale = 0.0f; + Menu_Ring->Appear_Animation->Ring_Draw_Counter = 0; + Menu_Ring->Appear_Animation->Center_Grow_Counter = 0; + Menu_Ring->Appear_Animation->Current_Item_Appearing = 0; + Menu_Ring->Appear_Animation->Current_Item_Scale = 0.0f; + Menu_Ring->Appear_Animation->Item_Pop_Counter = 0; + Menu_Ring->Appear_Animation->Item_Delay_Counter = 0; + + Menu_Ring->Appear_Animation_Active = true; + + // Hide all items initially during animation + for (uint32_t i = 0; i < Menu_Ring->Item_Count; i++) { + Menu_Ring->Item_Scales[i] = 0.0f; + Menu_Ring->Item_Glow_Intensity[i] = 0; + } + } +} + +bool Display_Objects_Menu_Ring_Is_Appear_Animation_Active(Object_ID menu_ring_id) +{ + Display_Object* Object = Display_Objects_Get_By_ID(menu_ring_id); + if (Object == NULL || Object->Type != MENU_RING) { + return false; + } + + Object_Menu_Ring* Menu_Ring = (Object_Menu_Ring*)Object->Data; + return Menu_Ring->Appear_Animation_Active; +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ +Object_ID Display_Objects_Add(Object_Type type, Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, void *data, Style_ID style_id, Animation_ID animation_id) +{ + Display_Object Object; + Object.Type = type; + Object.Coordinates.X = x; + Object.Coordinates.Y = y; + Object.Content_Offset.X = 0; + Object.Content_Offset.Y = 0; + Object.Dimension.Height = 0; + Object.Dimension.Width = 0; + Object.Enabled = true; + Object.Selectable = selectable; + Object.Focused = false; + Object.Data = data; + Object.Style = Display_Objects_Style_From_ID(style_id); + Object.Animation = Display_Objects_Animation_From_ID(animation_id); + Object.Animation_Status = NULL; + + Display_Objects_Update_Coordinates_Offset_And_Dimension(&Object, anchor_point, coordinates_type); + + if (Object.Animation != NULL) + { + Object.Animation_Status = malloc(sizeof(Animation_Status)); + Object.Animation_Status->State = NO_STARTED; + } + + // _Objects->used is the number of used entries, because _Objects->array[_Objects->used++] updates _Objects->used only *after* the array has been accessed. + // Therefore a->used can go up to a->size + if (_Objects.Used == _Objects.Size) + { + _Objects.Size++; + _Objects.Array = realloc(_Objects.Array, _Objects.Size * sizeof(Display_Object)); + } + + _Objects.Array[_Objects.Used++] = Object; + + return Display_Objects_Count() - 1; +} + +Style *Display_Objects_Style_From_ID(Style_ID style_id) +{ + if (style_id >= 0 && style_id < _Styles.Used) + { + return &_Styles.Array[style_id]; + } + + return NULL; +} + +Animation *Display_Objects_Animation_From_ID(Animation_ID animation_id) +{ + if (animation_id >= 0 && animation_id < _Animations.Used) + { + return &_Animations.Array[animation_id]; + } + + return NULL; +} + +Font* Display_Objects_Font_From_ID(Font_ID font_id) +{ + if (font_id >= 0 && font_id < _Fonts.Used) + { + return &_Fonts.Array[font_id]; + } + + return NULL; +} + +void Display_Objects_Update_Coordinates_Offset_And_Dimension(Display_Object *object, Anchor_Point anchor_point, Coordinates_Type coordinates_type) +{ + if (object == NULL) { + return; + } + + /////////////////////////////////////// + // Coordinated from Percent to Pixel // + /////////////////////////////////////// + Coordinates Coordinates_In_Px = { .X = object->Coordinates.X, .Y = object->Coordinates.Y }; + Display_Objects_Convert_Coordinates(coordinates_type, &Coordinates_In_Px); + + if(object->Type == SHAPE && ((Object_Shape*)object->Data)->Type == LINE_XY) { + Object_Shape* Shape = (Object_Shape*)object->Data; + Coordinates Coordinates_Line_X2Y2 = { .X = Shape->Angle_Start, .Y = Shape->Angle_End }; + Display_Objects_Convert_Coordinates(coordinates_type, &Coordinates_Line_X2Y2); + + Shape->Angle_Start = Coordinates_Line_X2Y2.X; + Shape->Angle_End = Coordinates_Line_X2Y2.Y; + } + + + //////////////////////////////////////// + // Get Coordinated of Top-Left corner // + //////////////////////////////////////// + Dimension Content_Size = Display_Objects_Get_Content_Size(object); + + Coordinates Coordinates_Content_Top_Left = Coordinates_In_Px; + + // Horizontal + switch (anchor_point & 0x0F) + { + case CENTER: + Coordinates_Content_Top_Left.X = Coordinates_In_Px.X - (Content_Size.Width >> 1); + break; + + case LEFT: + // Already assigned via default value + // Coordinates_Content_Top_Left.X = Coordinates_In_Px.X; + break; + + case RIGHT: + Coordinates_Content_Top_Left.X = Coordinates_In_Px.X - Content_Size.Width; + break; + } + + // Vertical + switch (anchor_point & 0xF0) + { + case MIDDLE: + Coordinates_Content_Top_Left.Y = Coordinates_In_Px.Y - (Content_Size.Height >> 1); + break; + + case TOP: + // Already assigned via default value + // Coordinates_Content_Top_Left.Y = Coordinates_In_Px.Y; + break; + + case BOTTOM: + Coordinates_Content_Top_Left.Y = Coordinates_In_Px.Y - Content_Size.Height; + break; + } + + Coordinates Offset_Content_Style = { .X = 0, .Y = 0 }; + Dimension Object_Dimension = Content_Size; + + if(object->Style != NULL) + { + Style* Style = object->Style; + + ////////////////////////////////////////////////////////// + // !!! HEIGHT and WIDTH of Style not yet considered !!! // + ////////////////////////////////////////////////////////// + + Offset_Content_Style.X = Style->Border_Thickness + Style->Padding[PADDING_LEFT]; + Offset_Content_Style.Y = Style->Border_Thickness + Style->Padding[PADDING_TOP]; + + Object_Dimension.Height += (Style->Border_Thickness << 1) + Style->Padding[PADDING_TOP] + Style->Padding[PADDING_BOTTOM]; + Object_Dimension.Width += (Style->Border_Thickness << 1) + Style->Padding[PADDING_LEFT] + Style->Padding[PADDING_RIGHT]; + + if(Style->Width_Height_Ratio != STYLE_WIDTH_HEIGHT_RATIO_AUTO) + { + uint16_t Ratio_Height = Object_Dimension.Width * Style->Width_Height_Ratio; + int16_t Height_Difference = Ratio_Height - Object_Dimension.Height; + + Object_Dimension.Height = Ratio_Height; + Offset_Content_Style.Y += (Height_Difference >> 1); + } + } + + object->Content_Offset = Offset_Content_Style; + object->Coordinates.X = Coordinates_Content_Top_Left.X - Offset_Content_Style.X; + object->Coordinates.Y = Coordinates_Content_Top_Left.Y - Offset_Content_Style.Y; + object->Dimension = Object_Dimension; +} + +void Display_Objects_Convert_Coordinates(Coordinates_Type coordinates_type, Coordinates* coordinates) +{ + switch (coordinates_type) + { + case BOTH_IN_PIXEL: + break; + + case X_IN_PIXEL_Y_IN_PERCENT: + coordinates->Y = (DISPLAY_HEIGHT * coordinates->Y) / 100; + break; + + case X_IN_PERCENT_Y_IN_PIXEL: + coordinates->X = (DISPLAY_WIDTH * coordinates->X) / 100; + break; + + case BOTH_IN_PERCENT: + coordinates->X = (DISPLAY_WIDTH * coordinates->X) / 100; + coordinates->Y = (DISPLAY_HEIGHT * coordinates->Y) / 100; + break; + + default: + break; + } +} + +Dimension Display_Objects_Get_Content_Size(Display_Object *object) +{ + Dimension Dimension = { .Width = 0, .Height = 0 }; + + if (object == NULL) + { + return Dimension; + } + + void *Data = object->Data; + char String[64]; + uint String_Char_Count; + + switch (object->Type) + { + case FLOAT: + Display_Font_Set_Font(((Object_Float *)Data)->Font->Font); + String_Char_Count = sprintf(String, ((Object_Float *)Data)->Format, *(((Object_Float *)Data)->Value)); + Dimension.Height = Display_Font_Get_Font_Height(); + Dimension.Width = Display_Font_Width_String(String, String_Char_Count, ((Object_Float *)Data)->Font->Character_Spacing); + break; + + case INTEGER: + Display_Font_Set_Font(((Object_Integer *)Data)->Font->Font); + String_Char_Count = sprintf(String, ((Object_Integer *)Data)->Format, *(((Object_Integer *)Data)->Value)); + Dimension.Height = Display_Font_Get_Font_Height(); + Dimension.Width = Display_Font_Width_String(String, String_Char_Count, ((Object_Integer *)Data)->Font->Character_Spacing); + break; + + case TEXT: + Display_Font_Set_Font(((Object_Text *)Data)->Font->Font); + Dimension.Height = Display_Font_Get_Font_Height(); + Dimension.Width = Display_Font_Width_String((((Object_Text *)Data)->Text), ((Object_Text *)Data)->Length, ((Object_Text *)Data)->Font->Character_Spacing); + break; + + case VALUE_BAR_RECT: + Dimension.Height = ((Object_Value_Bar_Rect *)Data)->Dimension.Height; + Dimension.Width = ((Object_Value_Bar_Rect *)Data)->Dimension.Width; + break; + + case GRAPH: + Dimension.Height = ((Object_Graph *)Data)->Dimension.Height; + Dimension.Width = ((Object_Graph *)Data)->Dimension.Width; + break; + + case BUTTON: + Dimension.Height = ((Object_Button *)Data)->Dimension.Height; + Dimension.Width = ((Object_Button *)Data)->Dimension.Width; + break; + + case IMAGE: + Dimension.Height = Display_Image_Get_Height(((Object_Image_Color*)Data)->Image); + Dimension.Width = Display_Image_Get_Width(((Object_Image_Color*)Data)->Image); + break; + + case BOOLEAN: + Display_Font_Set_Font(((Object_Bool *)Data)->Font->Font); + Dimension.Height = Display_Font_Get_Font_Height(); + if(((Object_Bool *)Data)->Length_True >= ((Object_Bool *)Data)->Length_False) + { + Dimension.Width = Display_Font_Width_String((((Object_Bool *)Data)->Text_True), ((Object_Bool *)Data)->Length_True, ((Object_Bool *)Data)->Font->Character_Spacing); + } + else + { + Dimension.Width = Display_Font_Width_String((((Object_Bool *)Data)->Text_False), ((Object_Bool *)Data)->Length_False, ((Object_Bool *)Data)->Font->Character_Spacing); + } + break; + + case SHAPE: + Dimension = Display_Objects_Get_Content_Size_From_Shape(object); + break; + + case CANVAS: + Dimension.Height = ((Object_Canvas *)Data)->Dimension.Height; + Dimension.Width = ((Object_Canvas *)Data)->Dimension.Width; + break; + + case MESSAGE_BOX: + Display_Font_Set_Font(((Object_Message_Box *)Data)->Font->Font); + Dimension.Height = Display_Font_Get_Font_Height() + MESSAGE_BOX_TEXT_BAR_DISTANCE + MESSAGE_BOX_BAR_HEIGHT; + Dimension.Width = Display_Font_Width_String((((Object_Message_Box *)Data)->Text), ((Object_Message_Box *)Data)->Length, ((Object_Message_Box *)Data)->Font->Character_Spacing); + + if((((Object_Message_Box *)Data)->Icon) != MESSAGE_BOX_ICON_NONE) { + Dimension.Width += MESSAGE_BOX_TEXT_ICON_DISTANCE + Display_Message_Box_Icons_Get_Icon_Width(((Object_Message_Box *)Data)->Icon); + + if(Display_Message_Box_Icons_Get_Icon_Height(((Object_Message_Box *)Data)->Icon) > Display_Font_Get_Font_Height()) { + Dimension.Height = Display_Message_Box_Icons_Get_Icon_Height(((Object_Message_Box *)Data)->Icon) + MESSAGE_BOX_TEXT_BAR_DISTANCE + MESSAGE_BOX_BAR_HEIGHT; + } + } + break; + + case MENU_SELECT: + case MENU_ICON_ROW: + case SELECT_YESNO: + case SELECT_LIST: + case SELECT_VALUE: + case SELECT_RGB: + Dimension.Height = 0; + Dimension.Width = 0; + break; + + default: + break; + } + + return Dimension; +} + +Dimension Display_Objects_Get_Content_Size_From_Shape(Display_Object *object) +{ + Dimension Dimension = { .Width = 0, .Height = 0 }; + + if(object->Type != SHAPE) { + return Dimension; + } + + Object_Shape* Shape = (Object_Shape *)object->Data; + + int16_t X1, X2, Y1, Y2; + + switch(Shape->Type) + { + case RECTANGLE_FILLED: + case ROUNDED_RECTANGLE_FILLED: + Dimension.Width = Shape->Dimension.Width; + Dimension.Height = Shape->Dimension.Height; + break; + + case RECTANGLE_FRAME: + case ROUNDED_RECTANGLE_FRAME: + Dimension.Width = Shape->Dimension.Width + Shape->Thickness; + Dimension.Height = Shape->Dimension.Height + Shape->Thickness; + break; + + case CIRCLE: + Dimension.Width = Shape->Radius_Start * 2; + Dimension.Height = Shape->Radius_Start * 2; + break; + + case ARC: + // This is still a ToDo + break; + + case LINE_XY: + Dimension.Width = abs(object->Coordinates.X - Shape->Angle_Start); // Angle_Start contains x2 + Dimension.Height = abs(object->Coordinates.Y - Shape->Angle_End); // Angle_End contains y2 + break; + + case LINE_RAD: + X1 = object->Coordinates.X + cos(Shape->Angle_Start * DEG2RAD) * Shape->Radius_Start; + Y1 = object->Coordinates.Y + sin(Shape->Angle_Start * DEG2RAD) * Shape->Radius_Start; + + X2 = object->Coordinates.X + cos(Shape->Angle_Start * DEG2RAD) * Shape->Radius_End; + Y2 = object->Coordinates.Y + sin(Shape->Angle_Start * DEG2RAD) * Shape->Radius_End; + + Dimension.Width = abs(X1 - X2); + Dimension.Height = abs(Y1 - Y2); + break; + + default: + break; + } + + return Dimension; +} \ No newline at end of file diff --git a/Firmware/Display_Objects.h b/Firmware/Display_Objects.h new file mode 100644 index 0000000..6ed1b99 --- /dev/null +++ b/Firmware/Display_Objects.h @@ -0,0 +1,106 @@ +/* + * Display_Objects.h + * + * Created: Fri Apr 02 2021 13:58:11 + * Author Chris + */ + +#ifndef DISPLAY_OBJECTS_H_ +#define DISPLAY_OBJECTS_H_ + +// ============================================================================================ +// Includes +#include +#include +#include +#include + +#include "Display_Config.h" +#include "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Defines +#define STYLE_WIDTH_HEIGHT_RATIO_AUTO 0 + + +// ============================================================================================ +// Variables / Datatypes +// See "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Function Declarations +void Display_Objects_Init(Display_Color background_color); + +void Display_Objects_Background_Color_Set(Display_Color color); +Display_Color Display_Objects_Background_Color_Get(void); +void Display_Objects_Clear(void); + +Style_ID Display_Objects_Add_Style( Display_Color background_color, + Display_Color border_color, uint border_thickness, uint border_radius, + uint padding_top, uint padding_right, uint padding_bottom, uint padding_left, + float width_height_ratio); + +Animation_ID Display_Objects_Add_Animation( int offset_x, + int offset_y, + uint tick_delay, + uint tick_duration, + Animation_Order start_condition); + +Font_ID Display_Objects_Add_Font( const unsigned char *font, + uint8_t character_spacing); + +size_t Display_Objects_Count(void); +Display_Object* Display_Objects_Get_By_ID(Object_ID id); + +size_t Display_Objects_Get_Count_Canvas(void); +Object_ID Display_Objects_Get_ID_From_Canvas_Number(uint canvas_number); + +Object_ID Display_Objects_Add_Float (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, float* value, char* format, Font_ID font , Display_Color color , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Integer (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, int* value, char* format, Font_ID font , Display_Color color , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Text (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, char* text, Font_ID font , Display_Color color , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Value_Bar_Rect (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, uint32_t* value, uint32_t max, uint32_t min, Orientation orientation, Display_Color color, uint32_t width, uint32_t height, Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Value_Bar_Arc ( Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, uint32_t* value, uint32_t max, uint32_t min, uint32_t delta_inc, uint32_t delta_dec, Display_Color color, + uint16_t radius, uint16_t thickness, uint16_t steps, int16_t angle_start, int16_t angle_end , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Graph (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, uint16_t* data, uint16_t data_length, uint max, uint min , Display_Color color , uint height , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Button (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, char* text, Font_ID font, uint return_value , Display_Color color, uint width, uint height , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Image (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Image_Color* image, uint16_t Rotation_Angle , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Bool (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, bool* value, char* text_true, Display_Color color_true, char* text_false, Display_Color color_false, Font_ID font , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Rectangle_Filled (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Rectangle_Frame (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height, uint16_t border_thickness , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Rounded_Rectangle_Filled(Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height, uint16_t radius , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Rounded_Rectangle_Frame (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint32_t width, uint32_t height, uint16_t radius, uint16_t border_thickness , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Circle_Frame (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint16_t radius, uint16_t thickness , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Arc_Frame ( Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint16_t radius, uint16_t thickness, uint16_t steps, int16_t angle_start, int16_t angle_end , Style_ID style_id, Animation_ID animation_id); +Object_ID Dispaly_Objects_Add_Line_XY ( Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, int16_t x2, int16_t y2, uint16_t thickness , Style_ID style_id, Animation_ID animation_id); +Object_ID Dispaly_Objects_Add_Line_Rad ( Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint16_t radius_start, uint16_t radius_end, uint16_t thickness, int16_t angle , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Canvas (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, bool selectable, Display_Color color, uint width, uint height , Style_ID style_id, Animation_ID animation_id); +Object_ID Display_Objects_Add_Message_Box (Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y, char* text, Font_ID font, Object_Message_Box_Icon icon, Display_Color color , Style_ID style_id); +Object_ID Display_Objects_Add_Menu_Select (char* menu_titles, uint32_t menu_entry_count, uint32_t title_char_length, uint32_t* selected_entry, Configuration_Menu_Select* config); +Object_ID Display_Objects_Add_Menu_Icon_Row (Icon_Row_Item* items, uint32_t item_count, uint32_t* selected_item, Configuration_Menu_Icon_Row* config); +Object_ID Display_Objects_Add_Menu_Ring (Menu_Ring_Item_Config* items, uint32_t item_count, uint32_t* selected_item, Configuration_Menu_Ring* config); +Object_ID Display_Objects_Add_Select_YesNo (char* title, uint32_t title_length, bool* value, Configuration_Select_YesNo* config); +Object_ID Display_Objects_Add_Select_List (char* list_titles, uint32_t list_entry_count, uint32_t list_char_length, uint32_t* selected_entry, Configuration_Select_List* config); +Object_ID Display_Objects_Add_Select_Value (char* title, uint32_t title_length, int32_t* value, int32_t max, int32_t min, char* format, Configuration_Select_Value* config); +Object_ID Display_Objects_Add_Select_RGB (RGB_Color* color_value, uint8_t* current_component, Configuration_Select_RGB* config); +Object_ID Display_Objects_Add_Entry_Indicator (uint32_t entry_count, int32_t* entry_value, Configuration_Entry_Indicator* config); + + +void Display_Objects_Update_Coordinates (Object_ID id, Anchor_Point anchor_point, Coordinates_Type coordinates_type, int16_t x, int16_t y); +void Display_Objects_Update_Enabled (Object_ID id, bool is_enabled); +void Display_Objects_Update_Color (Object_ID id, Display_Color color); +void Display_Objects_Update_Text (Object_ID id, char* text); +void Display_Objects_Update_Image (Object_ID id, Image_Color* new_image); +void Display_Objects_Update_Alpha (Object_ID id, uint8_t new_alpha); +void Display_Objects_Update_Max_Min (Object_ID id, uint max, uint min); +int Display_Objects_Update_Pixel (Object_ID id, int16_t x, int16_t y, Display_Color color); +void Display_Objects_Show_Message_Box (Object_ID id, uint32_t ticks); +void Display_Objects_Update_Angles_Rel (Object_ID id, int16_t angle_delta); +void Display_Objects_Update_Angle_Start (Object_ID id, int16_t angle); +void Display_Objects_Update_Angle_End (Object_ID id, int16_t angle); + +void Display_Objects_Menu_Ring_Start_Appear_Animation(Object_ID menu_ring_id); +bool Display_Objects_Menu_Ring_Is_Appear_Animation_Active(Object_ID menu_ring_id); + +#endif /* DISPLAY_OBJECTS_H_ */ diff --git a/Firmware/Display_Objects_Datatypes.h b/Firmware/Display_Objects_Datatypes.h new file mode 100644 index 0000000..5c85e4f --- /dev/null +++ b/Firmware/Display_Objects_Datatypes.h @@ -0,0 +1,669 @@ +/* + * Display_Objects_Datatypes.h + * + * Created: Sun Apr 04 2021 11:48:15 + * Author Chris + */ + +#ifndef DISPLAY_OBJECTS_DATATYPES_H_ +#define DISPLAY_OBJECTS_DATATYPES_H_ + +// ============================================================================================ +// Includes +#include "Display_Config.h" + + +// ============================================================================================ +// Defines +#define PADDING_TOP 0 +#define PADDING_RIGHT 1 +#define PADDING_BOTTOM 2 +#define PADDING_LEFT 3 + +#define HEIGHT_CONTENT 0 +#define WIDTH_CONTENT 0 + +#define NO_STYLE -1 +#define NO_ANIMATION -1 + +#define PADDING_1(__ALL__) __ALL__,__ALL__,__ALL__,__ALL__ +#define PADDING_2(__HOR__, __VER__) __HOR__,__VER__,__HOR__,__VER__ +#define PADDING_4(__T__, __R__, __B__, __L__) __T__,__R__,__B__,__L__ + +#define SELECTABLE true +#define NOT_SELECTABLE false + +#define TEXT_AND_LENGTH(_TEXT_) (uint8_t*)_TEXT_, sizeof(_TEXT_)-1 + +// Animation configuration constants (adjustable in frames) +#define MENU_RING_APPEAR_CIRCLE_DRAW_SPEED 12 // Frames per degree of circle drawing +#define MENU_RING_APPEAR_CIRCLE_GROW_SPEED 8 // Frames for center circle to grow to full size +#define MENU_RING_APPEAR_ITEM_POP_SPEED 4 // Frames for each item to appear +#define MENU_RING_APPEAR_ITEM_DELAY 1 // Frames between each item appearance + + +// ============================================================================================ +// Variables / Datatypes + +/******************************************************************* + Generic Types +*******************************************************************/ +typedef union +{ + struct + { + uint8_t R; + uint8_t G; + uint8_t B; + uint8_t A; // Alpha channel (unused, for 32-bit alignment) + }; + uint8_t Array[4]; + uint32_t Pixel; +} __packed RGB_Color; + +typedef enum { + FLOAT, + INTEGER, + TEXT, + VALUE_BAR_RECT, + VALUE_BAR_ARC, + GRAPH, + BUTTON, + IMAGE, + BOOLEAN, + SHAPE, + CANVAS, + MESSAGE_BOX, + MENU_SELECT, + MENU_ICON_ROW, + MENU_RING, + SELECT_YESNO, + SELECT_LIST, + SELECT_VALUE, + SELECT_RGB, + ENTRY_INDICATOR +} Object_Type; + +typedef enum { + RECTANGLE_FILLED, + RECTANGLE_FRAME, + ROUNDED_RECTANGLE_FILLED, + ROUNDED_RECTANGLE_FRAME, + CIRCLE, + ARC, + LINE_XY, + LINE_RAD +} Shape_Type; + +typedef enum +{ + CENTER = 0x00, + LEFT = 0x01, + RIGHT = 0x02, + + MIDDLE = 0x00, + TOP = 0x10, + BOTTOM = 0x20, + + CENTERED = CENTER | MIDDLE +} Alignment; + +typedef enum +{ + LEFT_TOP = LEFT | TOP, + LEFT_MIDDLE = LEFT | MIDDLE, + LEFT_BOTTOM = LEFT | BOTTOM, + + CENTER_TOP = CENTER | TOP, + CENTER_MIDDLE = CENTER | MIDDLE, + CENTER_BOTTOM = CENTER | BOTTOM, + + RIGHT_TOP = RIGHT | TOP, + RIGHT_MIDDLE = RIGHT | MIDDLE, + RIGHT_BOTTOM = RIGHT | BOTTOM +} Anchor_Point; + +typedef enum { + BOTH_IN_PIXEL, + X_IN_PIXEL_Y_IN_PERCENT, + X_IN_PERCENT_Y_IN_PIXEL, + BOTH_IN_PERCENT +} Coordinates_Type; + +typedef enum { + LEFT_TO_RIGHT, + RIGHT_TO_LEFT, + BOTTOM_TO_TOP, + TOP_TO_BOTTOM +} Orientation; + +typedef enum { + START_WITH_PREVIOUS, + START_AFTER_PREVIOUS +} Animation_Order; + +typedef enum { + NO_STARTED, + DELAYING, + MOVING, + COMPLETE +} Animation_State; + +typedef enum { + CANVAS_UPDATE_OK = 0, + OBJECT_NOT_FOUND = 1, + OBJECT_WRONG_TYPE = 2, + X_OUT_OF_RANGE = 3, + Y_OUT_OF_RANGE = 4 +} Canvas_Update_Error; + +typedef struct { + int16_t X; + int16_t Y; +} Coordinates; + +typedef struct { + uint16_t Width; + uint16_t Height; +} Dimension; + +typedef int Object_ID; +typedef int Style_ID; +typedef int Animation_ID; +typedef int Font_ID; + +typedef enum { + TRANSITION_NONE, + TRANSITION_LEFT, + TRANSITION_RIGHT, + TRANSITION_UP, + TRANSITION_DOWN +} Screen_Transition_Direction; + +// Animation states for menu ring appear effect +typedef enum { + MENU_RING_APPEAR_STATE_IDLE, // No animation running + MENU_RING_APPEAR_STATE_DRAWING_RING, // Drawing outer ring and growing center + MENU_RING_APPEAR_STATE_POPPING_ITEMS, // Items appearing one by one + MENU_RING_APPEAR_STATE_COMPLETE // Animation finished +} Menu_Ring_Appear_State; + + +/******************************************************************* + Font Type +*******************************************************************/ +typedef struct { + const unsigned char *Font; + uint8_t Character_Spacing; +} Font; + + +/******************************************************************* + Different Format Types +*******************************************************************/ +typedef struct { + float* Value; + char Format[64]; + Font* Font; + Display_Color Color; +} Object_Float; + +typedef struct { + int* Value; + char Format[64]; + Font* Font; + Display_Color Color; +} Object_Integer; + +typedef struct { + char Text[64]; + uint8_t Length; + Font* Font; + Display_Color Color; +} Object_Text; + +typedef struct { + Shape_Type Type; + Display_Color Color; + Dimension Dimension; + uint16_t Radius_Start; + uint16_t Radius_End; + uint16_t Thickness; + uint16_t Draw_Steps; + int16_t Angle_Start; + int16_t Angle_End; +} Object_Shape; + +typedef struct { + uint32_t* Value; + uint32_t Max; + uint32_t Min; + Orientation Orientation; + Display_Color Color; + Dimension Dimension; +} Object_Value_Bar_Rect; + +typedef struct { + uint32_t* Value; + uint32_t Max; + uint32_t Min; + uint32_t Current; + + uint32_t Delta_Inc; + uint32_t Delta_Dec; + + Object_Shape* Arc; + int16_t Angle_End; +} Object_Value_Bar_Arc; + +typedef struct { + uint16_t* Data; + uint16_t Data_Length; + uint Max; + uint Min; + Display_Color Color; + Dimension Dimension; +} Object_Graph; + +typedef struct { + char Text[64]; + uint8_t Length; + Font* Font; + uint Return_Value; + Display_Color Color; + Dimension Dimension; +} Object_Button; + +typedef const uint16_t Image_Color; +typedef const uint8_t Image_Alpha; + +typedef struct { + Image_Color *Image; + uint16_t Rotation_Angle; + uint8_t Alpha; +} Object_Image_Color; + +typedef struct { + bool* Value; + char Text_True[16]; + uint8_t Length_True; + Display_Color Color_True; + char Text_False[16]; + uint8_t Length_False; + Display_Color Color_False; + Font* Font; +} Object_Bool; + +typedef struct { + Dimension Dimension; + uint16_t* Data; +} Object_Canvas; + + +typedef enum { + MESSAGE_BOX_TEXT_BAR_DISTANCE = 2, + MESSAGE_BOX_BAR_HEIGHT = 3, + MESSAGE_BOX_TEXT_ICON_DISTANCE = 2 +} Object_Message_Box_Properties; + +typedef enum { + MESSAGE_BOX_ICON_NONE, + MESSAGE_BOX_ICON_CIRCLE_ADD, + MESSAGE_BOX_ICON_CIRCLE_ALERT, + MESSAGE_BOX_ICON_CRCLE_BAN, + MESSAGE_BOX_ICON_CHATBUBBLE, + MESSAGE_BOX_ICON_CIRCLE_CHECKMARK, + MESSAGE_BOX_ICON_CIRCLE_CLOSE, + MESSAGE_BOX_ICON_CIRCLE_INFORMATION, + MESSAGE_BOX_ICON_EMOJI_HAPPY, + MESSAGE_BOX_ICON_EMOJI_SAD, + MESSAGE_BOX_ICON_EMOJI_SKULL +} Object_Message_Box_Icon; + +typedef struct { + char Text[64]; + uint8_t Length; + Font* Font; + Display_Color Color; + Object_Message_Box_Icon Icon; + + uint32_t Show_Ticks_Max; + uint32_t Show_Ticks_Left; +} Object_Message_Box; + + +typedef struct { + int16_t X_Offset; + int16_t X_Indent; + + const unsigned char *Font[3]; + Display_Color Color[3]; +} Configuration_Menu_Select; + +typedef struct { + char* Menu_Titles; + uint32_t Menu_Entry_Count; + uint32_t Title_Char_Length; + uint32_t* Selected_Entry; + Configuration_Menu_Select* Config; +} Object_Menu_Select; + + +typedef struct { + uint32_t Icon_Space_Width; + float Shrink_Factor; + int16_t Y_Images; + int16_t Y_Images_Warp; + int16_t Y_Text; + + const unsigned char *Font; + Display_Color Color; +} Configuration_Menu_Icon_Row; + +typedef struct { + Image_Color* Image; + char* Title; + uint32_t Title_Length; +} Icon_Row_Item; + +typedef struct { + Icon_Row_Item* Items; + uint32_t Item_Count; + uint32_t* Selected_Item; + + Configuration_Menu_Icon_Row* Config; +} Object_Menu_Icon_Row; + + +// Animation data structure +typedef struct { + Menu_Ring_Appear_State State; + + // Phase 1: Ring drawing and center growing + float Ring_Draw_Angle; // Current angle of ring drawn (0-360) + float Center_Scale; // Current scale of center circle (0-1) + uint32_t Ring_Draw_Counter; // Frame counter for ring drawing + uint32_t Center_Grow_Counter; // Frame counter for center growing + + // Phase 2: Item popping + uint32_t Current_Item_Appearing; // Which item is currently appearing (0-item_count) + float Current_Item_Scale; // Scale of currently appearing item (0-1) + uint32_t Item_Pop_Counter; // Frame counter for current item + uint32_t Item_Delay_Counter; // Frame counter for delay between items + + // Animation timing + uint32_t Total_Ring_Draw_Frames; // Total frames to draw complete ring + uint32_t Total_Center_Grow_Frames; // Total frames to grow center + uint32_t Total_Item_Pop_Frames; // Total frames for one item to appear + uint32_t Total_Item_Delay_Frames; // Total frames to wait between items +} Menu_Ring_Appear_Animation; + +typedef struct { + const char* Label; + Image_Color* Icon; +} Menu_Ring_Item_Config; + +typedef struct { + // Colors + Display_Color Center_Text_Color; + Display_Color Center_BG_Color; + Display_Color Center_Border_Color; + Display_Color Selection_Ring_Color; + + // Fonts + const unsigned char *Center_Text_Font; + + // Layout dimensions + uint16_t Item_Radius; // Distance from center to items + uint16_t Center_Size; // Diameter of center circle + uint16_t Image_Size; // Expected image size (renamed for clarity) + + // Animation settings + float Selection_Scale; // Scale factor for selected item + uint16_t Animation_Duration; // Animation duration in frames + float Idle_Rotation_Speed; // Degrees per frame for idle animation + + // Selection ring parameters + uint16_t Selection_Ring_Diameter; // Diameter of selection ring (0 = auto-calculate from image) + uint16_t Selection_Ring_Thickness; // Thickness of selection ring border (default: 3) + uint16_t Selection_Ring_Padding; // Extra padding around image (default: 4) + + // Layout options + float Start_Angle_Degrees; // Starting angle for first item + bool Distribute_Evenly; // If true, items are evenly spaced + float Fixed_Angle_Step; // Fixed angle between items + + // Appear animation settings + bool Enable_Appear_Animation; // Enable/disable appear animation +} Configuration_Menu_Ring; + +typedef struct { + Menu_Ring_Item_Config* Items; // Dynamic array of menu items + uint32_t Item_Count; // Number of items + uint32_t* Selected_Item; // Pointer to current selection (0 to item_count-1) + Configuration_Menu_Ring* Config; + + // Internal animation state (dynamic arrays) + uint32_t Animation_Counter; + float Idle_Rotation_Angle; + uint32_t Selection_Animation_Progress; + uint32_t Animation_Target; + float* Item_Scales; // Dynamic array of scales + uint8_t* Item_Glow_Intensity; // Dynamic array of glow intensities + + // Appear animation state + Menu_Ring_Appear_Animation* Appear_Animation; + bool Appear_Animation_Active; +} Object_Menu_Ring; + + +typedef struct { + const unsigned char *Title_Font; + Display_Color Title_Color; + int16_t Title_Y_Center; + + const unsigned char *Value_Font; + int16_t Value_Center_X_Offset; + int16_t Value_Y_Center; + uint16_t Animation_Speed; +} Configuration_Select_YesNo; + +typedef struct { + char* Title; + uint32_t Title_Length; + + bool* Value; + + Configuration_Select_YesNo* Config; +} Object_Select_YesNo; + + +typedef struct { + const unsigned char *Font; + int16_t List_Entry_Y_Gap; + Display_Color Color_Selected; + Display_Color Color_Not_Selected; +} Configuration_Select_List; + +typedef struct { + char* List_Titles; + uint32_t List_Entry_Count; + uint32_t List_Char_Length; + uint32_t* Selected_Entry; + Configuration_Select_List* Config; +} Object_Select_List; + + +typedef struct { + const unsigned char *Title_Font; + Display_Color Title_Color; + int16_t Title_Y_Center; + + const unsigned char *Value_Font; + Display_Color Value_Color; + int16_t Value_Y_Center; + + bool Show_Arc; + Display_Color Arc_Color; +} Configuration_Select_Value; + +typedef struct { + char* Title; + uint32_t Title_Length; + + int32_t* Value; + int32_t Max; + int32_t Min; + + char Format[32]; + + Configuration_Select_Value* Config; +} Object_Select_Value; + +/******************************************************************* + SELECT_RGB Configuration and Object Structure +*******************************************************************/ +typedef struct { + // Ring colors for each RGB component + Display_Color Ring_Color_Red; + Display_Color Ring_Color_Green; + Display_Color Ring_Color_Blue; + + // Geometry settings + uint16_t Center_Preview_Radius; // Radius of central color preview circle + uint16_t Progress_Ring_Radius; // Radius of progress ring + uint16_t Progress_Ring_Thickness; // Thickness of progress ring + uint16_t Indicator_Radius; // Radius of value indicator dot + + // Colors for UI elements + Display_Color Preview_Border_Color; // Border color for preview circle + uint16_t Preview_Border_Thickness; // Border thickness for preview circle + Display_Color Indicator_Core_Color; // Core color of indicator dot + Display_Color Indicator_Glow_Color; // Glow color of indicator dot + Display_Color Background_Ring_Color; // Color for unfilled part of ring + uint16_t Background_Ring_Thickness; // Thickness of background ring + + // Previous color markers + Display_Color Previous_Marker_Color; // Color for previous component markers + uint16_t Previous_Marker_Radius; // Radius of previous marker dots + uint16_t Previous_Marker_Ring_Offset; // Distance from main ring (inner offset) + bool Show_Previous_Markers; // Enable/disable previous markers + + // Text display settings + const unsigned char* Component_Label_Font; // Font for "RED", "GREEN", "BLUE" labels + const unsigned char* Value_Font; // Font for numeric value display + Display_Color Text_Color; // Color for all text elements + int16_t Text_Y_Offset; // Vertical offset from bottom for text + + // Animation settings + uint16_t Smooth_Animation_Steps; // Steps for smooth value transitions + bool Enable_Encoder_Acceleration; // Enable faster changes on fast rotation + uint8_t Acceleration_Threshold; // Encoder speed threshold for acceleration + uint8_t Acceleration_Multiplier; // Multiplier for fast rotation (2-10) + +} Configuration_Select_RGB; + +typedef struct { + // RGB value pointer + RGB_Color* Color_Value; // Pointer to RGB color structure + + // Current state + uint8_t *Current_Component; // Active component: 0=Red, 1=Green, 2=Blue + uint8_t Component_Labels[3][6]; // Text labels: "RED", "GREEN", "BLUE" + + // Animation state + uint8_t Target_Value; // Target value for smooth animation + uint8_t Display_Value; // Currently displayed value (for smooth transitions) + uint16_t Animation_Counter; // Counter for smooth value changes + + // UI geometry (calculated at setup) + uint16_t Progress_Start_Angle; // Starting angle for progress arc (270° = 12 o'clock) + + // Configuration pointer + Configuration_Select_RGB* Config; +} Object_Select_RGB; + + + + +typedef enum { + INDICATOR_ARC, + INDICATOR_DOT +} Type_Entry_Endicator; + +typedef struct { + Type_Entry_Endicator Type; + + Display_Color Color_Selected; + Display_Color Color_Unselected; + + union Options { + struct { + int16_t Angle_Span; + uint16_t Thickness; + uint16_t Radius; + } Arc; + struct { + int16_t Y; + uint16_t Dot_Size; + uint16_t Dot_Distance; + bool Unselected_Frame_Only; + } Dot; + } Options; +} Configuration_Entry_Indicator; + +typedef struct { + uint32_t Entry_Count; + int32_t* Entry_Value; + + Configuration_Entry_Indicator* Config; +} Object_Entry_Indicator; + +/******************************************************************* + Style Type +*******************************************************************/ +typedef struct { + Display_Color Background_Color; + Display_Color Border_Color; + uint Border_Thickness; + uint Border_Radius; + uint Padding[4]; + float Width_Height_Ratio; +} Style; + + +/******************************************************************* + Animation Type +*******************************************************************/ +typedef struct { + Coordinates Offset; + uint Tick_Delay; + uint Tick_Duration; + Animation_Order Animation_Start; +} Animation; + +typedef struct { + Coordinates Target; + Animation_State State; + uint Tick_Counter; +} Animation_Status; + + +/******************************************************************* + Main Object Type +*******************************************************************/ +typedef struct { + Object_Type Type; + Coordinates Coordinates; + Coordinates Content_Offset; + Dimension Dimension; + bool Enabled; + bool Selectable; + bool Focused; + void* Data; + Style* Style; + Animation* Animation; + Animation_Status* Animation_Status; +} Display_Object; + +#endif /* DISPLAY_OBJECTS_DATATYPES_H_ */ \ No newline at end of file diff --git a/Firmware/Display_SPI.c b/Firmware/Display_SPI.c new file mode 100644 index 0000000..b653a13 --- /dev/null +++ b/Firmware/Display_SPI.c @@ -0,0 +1,189 @@ +/* + * Display_SPI.c + * + * Created: Sun Mar 21 2021 11:51:35 + * Author Chris + */ +#include "Display_SPI.h" +#include "Display_Config.h" + +#include "pico/stdlib.h" +#include "hardware/spi.h" +#include "hardware/dma.h" +#include "hardware/irq.h" +#include "pico/binary_info.h" +#include "hardware/structs/spi.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables +static uint _Baudrate; +static bool _SPI_Received_Initialized; +volatile bool _DMA_Transfer_Complete; +static uint _DMA_Transmit_Claim; +static dma_channel_config _DMA_Transmit_Channel; + + +// ============================================================================================ +// Function Declarations +static inline void Display_SPI_CS_Select(); +static inline void Display_SPI_CS_Deselect(); + + +/******************************************************************* + Interrupt Service Routines +*******************************************************************/ +void ISR_SPI_DMA_Transmit_Complete() +{ + dma_hw->ints0 = (1u << _DMA_Transmit_Claim); + Display_SPI_CS_Deselect(); + + _DMA_Transfer_Complete = true; +} + +/******************************************************************* + Functions +*******************************************************************/ +void Display_SPI_Init(bool init_spi_receive) +{ + _SPI_Received_Initialized = init_spi_receive; + + _Baudrate = spi_init(DISPLAY_SPI_PORT, DISPLAY_SPI_BAUDRATE); + + // Initialize SPI Pinss defined in Config-Struct + gpio_set_slew_rate (DISPLAY_SPI_PIN_SCK, GPIO_SLEW_RATE_FAST); + gpio_set_slew_rate (DISPLAY_SPI_PIN_MOSI, GPIO_SLEW_RATE_FAST); + gpio_set_function (DISPLAY_SPI_PIN_SCK, GPIO_FUNC_SPI); + gpio_set_function (DISPLAY_SPI_PIN_MOSI, GPIO_FUNC_SPI); + + if(_SPI_Received_Initialized == true) { + gpio_set_function(DISPLAY_SPI_PIN_MISO, GPIO_FUNC_SPI); + } + + // Initialize CS-Pin as regular GPIO + gpio_init (DISPLAY_SPI_PIN_CS); + gpio_set_dir (DISPLAY_SPI_PIN_CS, GPIO_OUT); + gpio_set_slew_rate (DISPLAY_SPI_PIN_CS, GPIO_SLEW_RATE_FAST); + + Display_SPI_CS_Deselect(); + + + // Configura DMA Channel for SPI Transmit function + _DMA_Transmit_Claim = dma_claim_unused_channel(true); + _DMA_Transmit_Channel = dma_channel_get_default_config(_DMA_Transmit_Claim); + channel_config_set_transfer_data_size(&_DMA_Transmit_Channel, DMA_SIZE_8); + channel_config_set_dreq(&_DMA_Transmit_Channel, spi_get_index(DISPLAY_SPI_PORT) ? DREQ_SPI1_TX : DREQ_SPI0_TX); + dma_channel_configure( _DMA_Transmit_Claim, + &_DMA_Transmit_Channel, + &spi_get_hw(DISPLAY_SPI_PORT)->dr, // Write Address + NULL, // Read Address + 0, // Element Count (Each element is of size transfer_data_size) + false); // DO NOT start directly + + + dma_channel_set_irq0_enabled(_DMA_Transmit_Claim, true); + + // Configure the processor to run the ISR when DMA IRQ 0 is asserted + irq_set_exclusive_handler(DMA_IRQ_0, ISR_SPI_DMA_Transmit_Complete); + irq_set_enabled(DMA_IRQ_0, true); + + _DMA_Transfer_Complete = true; +} + +void Display_SPI_Start_Command(uint8_t command) +{ + DISPLAY_MODE_SET_CMD(); + Display_SPI_CS_Select(); + spi_write_blocking(DISPLAY_SPI_PORT, &command, 1); + DISPLAY_MODE_SET_DATA(); +} + +void Display_SPI_Start_Parameter(uint8_t parameter) +{ + spi_write_blocking(DISPLAY_SPI_PORT, ¶meter, 1); +} + +void Display_SPI_Start_Parameter_Array(uint8_t* parameter_array, uint length) +{ + spi_write_blocking(DISPLAY_SPI_PORT, parameter_array, length); +} + +void Display_SPI_Finish_Command(void) +{ + Display_SPI_CS_Deselect(); +} + +void Display_SPI_Send_Data(uint8_t* data, uint length, bool use_dma) +{ + Display_SPI_CS_Select(); + if(use_dma) { + if(dma_channel_is_busy(_DMA_Transmit_Claim)) { + return; + } + + dma_channel_set_read_addr (_DMA_Transmit_Claim, data , false); + dma_channel_set_trans_count (_DMA_Transmit_Claim, length, true); + } else { + spi_write_blocking(DISPLAY_SPI_PORT, data, length); + Display_SPI_CS_Deselect(); + } +} + +void Display_SPI_Set_Baudrate(uint baudrate) +{ + _Baudrate = spi_init(DISPLAY_SPI_PORT, baudrate); // This works when changing the Baudrate during runtime + // Using the function 'spi_set_baudrate' bring some problems + // _Baudrate = spi_set_baudrate(DISPLAY_SPI_PORT, baudrate); +} + +uint Display_SPI_Get_Baudrate(void) +{ + return _Baudrate; +} + +bool Display_SPI_DMA_Transfer_Ongoing(void) +{ + return dma_channel_is_busy(_DMA_Transmit_Claim); +} + +bool Display_SPI_DMA_Transfer_Completed(void) +{ + bool Return_Value = _DMA_Transfer_Complete; + + _DMA_Transfer_Complete = false; + + return Return_Value; +} + +bool Display_SPI_Read_Write(const uint8_t* write_data, uint8_t* read_data, uint length_both_buffers) +{ + if(_SPI_Received_Initialized == false) { + return false; + } + + int Bytes_Read_Write; + Bytes_Read_Write = spi_write_read_blocking(DISPLAY_SPI_PORT, write_data, read_data, length_both_buffers); + + return (Bytes_Read_Write == length_both_buffers); +} + +/******************************************************************* + Internal Functions +*******************************************************************/ +static inline void Display_SPI_CS_Select() +{ + asm volatile("nop \n nop \n nop"); + gpio_put(DISPLAY_SPI_PIN_CS, 0); // Active low + asm volatile("nop \n nop \n nop"); +} + +static inline void Display_SPI_CS_Deselect() +{ + asm volatile("nop \n nop \n nop"); + gpio_put(DISPLAY_SPI_PIN_CS, 1); + asm volatile("nop \n nop \n nop"); +} \ No newline at end of file diff --git a/Firmware/Display_SPI.h b/Firmware/Display_SPI.h new file mode 100644 index 0000000..53fca06 --- /dev/null +++ b/Firmware/Display_SPI.h @@ -0,0 +1,47 @@ +/* + * Display_SPI.h + * + * Created: Sun Mar 21 2021 11:51:32 + * Author Chris + */ +#ifndef DISPLAY_SPI_H_ +#define DISPLAY_SPI_H_ + +// ============================================================================================ +// Includes +#include +#include +#include + +#include "pico/types.h" +#include "hardware/spi.h" +#include "Display_Config.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Display_SPI_Init(bool init_spi_receive); + +void Display_SPI_Start_Command(uint8_t command); +void Display_SPI_Start_Parameter(uint8_t parameter); +void Display_SPI_Start_Parameter_Array(uint8_t* parameter_array, uint length); +void Display_SPI_Finish_Command(void); + +void Display_SPI_Send_Data(uint8_t* data, uint length, bool use_dma); + +void Display_SPI_Set_Baudrate(uint baudrate); +uint Display_SPI_Get_Baudrate(void); +bool Display_SPI_DMA_Transfer_Ongoing(void); +bool Display_SPI_DMA_Transfer_Completed(void); + +bool Display_SPI_Read_Write(const uint8_t* write_data, uint8_t* read_data, uint length_both_buffers); + +#endif /* DISPLAY_SPI_H_ */ \ No newline at end of file diff --git a/Firmware/Display_Shapes.c b/Firmware/Display_Shapes.c new file mode 100644 index 0000000..d0a4186 --- /dev/null +++ b/Firmware/Display_Shapes.c @@ -0,0 +1,760 @@ +/* + * Display_Shapes.c + * + * Created: Mon Jul 19 2021 17:57:03 + * Author Chris + */ +#include "Display_Shapes.h" +#include "Display_Color.h" +#include "Display_Objects.h" + +#include "hardware/dma.h" + +#include +#include +#include +#include +#include +#include + + +// ============================================================================================ +// Defines +#define CORNER_TOP_LEFT 0x01 +#define CORNER_TOP_RIGHT 0x02 +#define CORNER_BOTTOM_RIGHT 0x04 // Fixed: was incorrectly 0x08 +#define CORNER_BOTTOM_LEFT 0x08 // Fixed: was incorrectly 0x04 + +#define DEG2RAD (float)(M_PI / 180) + +#define RECT_WIDTH_DMA_THRESHOLD 16 + + +// ============================================================================================ +// Variables +static Display_Image_Buffer** _Current_Buffer; + +static int _DMA_Channel_Fill_Screen; +static dma_channel_config _DMA_Config_Fill_Screen; + +static int _DMA_Channel_Drawing; +static dma_channel_config _DMA_Config_Drawing; + + +// ============================================================================================ +// Function Declarations +void Display_Shapes_Draw_Circle_Helper(int16_t x0, int16_t y0, uint16_t radius, uint16_t thickness, uint8_t cornername, Display_Color color); +void Display_Shapes_Draw_Circle_Helper_Improved(int16_t x0, int16_t y0, uint16_t radius, uint16_t thickness, uint8_t cornername, Display_Color color); +void Display_Shapes_Draw_Circle_Helper_Single_Pixel(int16_t x0, int16_t y0, uint16_t radius, uint8_t cornername, Display_Color color); +void Display_Shapes_Draw_Circle_Helper_Filled(int16_t x0, int16_t y0, uint16_t radius, uint8_t corners, int16_t delta, Display_Color color); + + +/******************************************************************* + Functions +*******************************************************************/ +void Display_Shapes_Init(Display_Image_Buffer** current_buffer) +{ + _Current_Buffer = current_buffer; + + _DMA_Channel_Fill_Screen = dma_claim_unused_channel(true); + _DMA_Config_Fill_Screen = dma_channel_get_default_config(_DMA_Channel_Fill_Screen); + channel_config_set_transfer_data_size(&_DMA_Config_Fill_Screen, DMA_SIZE_32); + channel_config_set_read_increment(&_DMA_Config_Fill_Screen, false); + channel_config_set_write_increment(&_DMA_Config_Fill_Screen, true); + + + _DMA_Channel_Drawing = dma_claim_unused_channel(true); + _DMA_Config_Drawing = dma_channel_get_default_config(_DMA_Channel_Drawing); + channel_config_set_transfer_data_size(&_DMA_Config_Drawing, DMA_SIZE_32); + channel_config_set_read_increment(&_DMA_Config_Drawing, false); + channel_config_set_write_increment(&_DMA_Config_Drawing, true); +} + +void Display_Shapes_Fill_Screen(Display_Color color) +{ + static uint32_t Clear_Value; + Clear_Value = (color << 16) | color; // Duplicate 16-bit value + + dma_channel_configure(_DMA_Channel_Fill_Screen, &_DMA_Config_Fill_Screen, (*_Current_Buffer)->Dim_1, &Clear_Value, DISPLAY_IMAGE_BUFFER_PIXEL_SIZE/2, false); // Half the transfers + dma_channel_start(_DMA_Channel_Fill_Screen); + dma_channel_wait_for_finish_blocking(_DMA_Channel_Fill_Screen); +} + +void Display_Shapes_Draw_Pixel_Safe(int16_t x, int16_t y, Display_Color color) +{ + if(x >= 0 && x < DISPLAY_WIDTH && y >= 0 && y < DISPLAY_HEIGHT) + { + (*_Current_Buffer)->Dim_2[y][x] = color; + } +} + +void Display_Shapes_Draw_HLine(int16_t x, int16_t y, uint16_t width, uint16_t thickness, Display_Color color) +{ + Display_Shapes_Draw_Rect_Filled(x, y, width, thickness, color); +} + +void Display_Shapes_Draw_VLine(int16_t x, int16_t y, uint16_t height, uint16_t thickness, Display_Color color) +{ + Display_Shapes_Draw_Rect_Filled(x, y, thickness, height, color); +} + +void Display_Shapes_Draw_Line_XY(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t thickness, Display_Color color) +{ + int16_t Temp; + + if(y0 == y1) + { + if(x1 > x0) + { + Display_Shapes_Draw_HLine(x0, y0, x1 - x0 + 1, thickness, color); + } + else if (x1 < x0) + { + Display_Shapes_Draw_HLine(x1, y0, x0 - x1 + 1, thickness, color); + } + else + { + Display_Shapes_Draw_Circle_Filled(x0, y0, thickness, color); + } + return; + } + else if(x0 == x1) + { + if(y1 > y0) + { + Display_Shapes_Draw_VLine(x0, y0, y1 - y0 + 1, thickness, color); + } + else + { + Display_Shapes_Draw_VLine(x0, y1, y0 - y1 + 1, thickness, color); + } + return; + } + + bool Steep = abs(y1 - y0) > abs(x1 - x0); + if(Steep == true) + { + Temp = x0; x0 = y0; y0 = Temp; + Temp = x1; x1 = y1; y1 = Temp; + } + if(x0 > x1) + { + Temp = x0; x0 = x1; x1 = Temp; + Temp = y0; y0 = y1; y1 = Temp; + } + + int16_t dx, dy; + dx = x1 - x0; + dy = abs(y1 - y0); + + int16_t err = dx / 2; + int16_t ystep; + + if (y0 < y1) + { + ystep = 1; + } + else + { + ystep = -1; + } + + int16_t xbegin = x0; + if(Steep == true) + { + for (; x0<=x1; x0++) + { + err -= dy; + if (err < 0) + { + int16_t len = x0 - xbegin; + if (len>1) + { + Display_Shapes_Draw_VLine(y0, xbegin, len + 1, thickness, color); + } + else + { + if(thickness == 1) + Display_Shapes_Draw_Pixel_Safe(y0, x0, color); + else + Display_Shapes_Draw_Circle_Filled(y0, x0, thickness >> 1, color); + } + xbegin = x0 + 1; + y0 += ystep; + err += dx; + } + } + if (x0 > xbegin + 1) + { + Display_Shapes_Draw_VLine(y0, xbegin, x0 - xbegin, thickness, color); + } + + } + else + { + for (; x0<=x1; x0++) + { + err -= dy; + if (err < 0) + { + int16_t len = x0 - xbegin; + if (len>1) + { + Display_Shapes_Draw_HLine(xbegin, y0, len + 1, thickness, color); + } + else + { + if(thickness == 1) + Display_Shapes_Draw_Pixel_Safe(x0, y0, color); + else + Display_Shapes_Draw_Circle_Filled(x0, y0, thickness >> 1, color); + } + xbegin = x0 + 1; + y0 += ystep; + err += dx; + } + } + if (x0 > xbegin + 1) + { + Display_Shapes_Draw_HLine(xbegin, y0, x0 - xbegin, thickness, color); + } + } +} + +void Display_Shapes_Draw_Line_Rad(int16_t x, int16_t y, float angle, uint16_t radius_start, uint16_t radius_end, uint16_t thickness, Display_Color color) +{ + int16_t X0 = x + cos(angle * DEG2RAD) * radius_start; + int16_t Y0 = y + sin(angle * DEG2RAD) * radius_start; + + int16_t X1 = x + cos(angle * DEG2RAD) * radius_end; + int16_t Y1 = y + sin(angle * DEG2RAD) * radius_end; + + Display_Shapes_Draw_Line_XY(X0, Y0, X1, Y1, thickness, color); +} + +void Display_Shapes_Draw_Rect_Frame(int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t thickness, Display_Color color) +{ + Display_Shapes_Draw_HLine(x , y , width , thickness, color); + Display_Shapes_Draw_HLine(x , y + height, width + thickness , thickness, color); + + Display_Shapes_Draw_VLine(x , y , height , thickness, color); + Display_Shapes_Draw_VLine(x + width , y , height + thickness, thickness, color); +} + +void Display_Shapes_Draw_Rect_Filled(int16_t x, int16_t y, uint16_t width, uint16_t height, Display_Color color) +{ + // Early bounds checking + if (x >= DISPLAY_WIDTH || y >= DISPLAY_HEIGHT || x + width <= 0 || y + height <= 0) { + return; + } + + // Clip to screen bounds + int16_t Start_X = (x < 0) ? 0 : x; + int16_t Start_Y = (y < 0) ? 0 : y; + int16_t End_X = (x + width > DISPLAY_WIDTH) ? DISPLAY_WIDTH : x + width; + int16_t End_Y = (y + height > DISPLAY_HEIGHT) ? DISPLAY_HEIGHT : y + height; + + uint16_t Clipped_Width = End_X - Start_X; + uint16_t Clipped_Height = End_Y - Start_Y; + + if (Clipped_Width == 0 || Clipped_Height == 0) { + return; + } + + // For wide rectangles, use DMA for each horizontal row (memory-contiguous) + if (Clipped_Width >= RECT_WIDTH_DMA_THRESHOLD) // DMA threshold for width + { + static uint32_t Fill_Value; + Fill_Value = (color << 16) | color; // Pack two 16-bit values + + for (int16_t row = Start_Y; row < End_Y; row++) { + // Calculate destination address for this row + Display_Color* Dst = &(*_Current_Buffer)->Dim_2[row][Start_X]; + + // Use DMA for horizontal row fill (contiguous memory) + dma_channel_configure(_DMA_Channel_Drawing, &_DMA_Config_Drawing, Dst, &Fill_Value, Clipped_Width / 2, false); + dma_channel_start(_DMA_Channel_Drawing); + dma_channel_wait_for_finish_blocking(_DMA_Channel_Drawing); + + // Handle odd width + if (Clipped_Width & 1) { + (*_Current_Buffer)->Dim_2[row][End_X - 1] = color; + } + } + } + else + { + // For narrow rectangles, use optimized nested loop + for (int16_t row = Start_Y; row < End_Y; row++) + { + // Each row is contiguous in memory - cache friendly + Display_Color* Row_Ptr = &(*_Current_Buffer)->Dim_2[row][Start_X]; + + for (int16_t col = 0; col < Clipped_Width; col++) + { + Row_Ptr[col] = color; + } + } + } +} + +void Display_Shapes_Draw_Circle_Frame(int16_t center_x, int16_t center_y, uint16_t radius, uint16_t thickness, Display_Color color) +{ + if(thickness == 0) { + return; + } + + int16_t f = 1 - radius; + int16_t ddF_x = 1; + int16_t ddF_y = -2 * radius; + int16_t X = 0; + int16_t Y = radius; + + if(thickness == 1) + { + Display_Shapes_Draw_Pixel_Safe(center_x , center_y+radius , color); + Display_Shapes_Draw_Pixel_Safe(center_x , center_y-radius , color); + Display_Shapes_Draw_Pixel_Safe(center_x+radius , center_y , color); + Display_Shapes_Draw_Pixel_Safe(center_x-radius , center_y , color); + } + else + { + Display_Shapes_Draw_Circle_Filled(center_x , center_y+radius , thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x , center_y-radius , thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x+radius , center_y , thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x-radius , center_y , thickness >> 1, color); + } + + while (X= 0) + { + Y--; + ddF_y += 2; + f += ddF_y; + } + X++; + ddF_x += 2; + f += ddF_x; + + if(thickness == 1) + { + Display_Shapes_Draw_Pixel_Safe(center_x + X, center_y + Y, color); + Display_Shapes_Draw_Pixel_Safe(center_x - X, center_y + Y, color); + Display_Shapes_Draw_Pixel_Safe(center_x + X, center_y - Y, color); + Display_Shapes_Draw_Pixel_Safe(center_x - X, center_y - Y, color); + Display_Shapes_Draw_Pixel_Safe(center_x + Y, center_y + X, color); + Display_Shapes_Draw_Pixel_Safe(center_x - Y, center_y + X, color); + Display_Shapes_Draw_Pixel_Safe(center_x + Y, center_y - X, color); + Display_Shapes_Draw_Pixel_Safe(center_x - Y, center_y - X, color); + } + else + { + Display_Shapes_Draw_Circle_Filled(center_x + X, center_y + Y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x - X, center_y + Y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x + X, center_y - Y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x - X, center_y - Y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x + Y, center_y + X, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x - Y, center_y + X, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x + Y, center_y - X, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(center_x - Y, center_y - X, thickness >> 1, color); + } + } +} + +void Display_Shapes_Draw_Circle_Filled(int16_t center_x, int16_t center_y, uint16_t radius, Display_Color color) +{ + Display_Shapes_Draw_VLine(center_x, center_y-radius, 2*radius+1, 1, color); + + uint8_t Corner_Name = 3; + int16_t Delta = 0; + + int16_t f = 1 - radius; + int16_t ddF_x = 1; + int16_t ddF_y = -2 * radius; + int16_t X = 0; + int16_t Y = radius; + + while(X= 0) + { + Y--; + ddF_y += 2; + f += ddF_y; + } + X++; + ddF_x += 2; + f += ddF_x; + + if ((Corner_Name & 0x1) > 0) + { + Display_Shapes_Draw_VLine(center_x+X, center_y-Y, 2*Y+1+Delta, 1, color); + Display_Shapes_Draw_VLine(center_x+Y, center_y-X, 2*X+1+Delta, 1, color); + } + if ((Corner_Name & 0x2)>0) + { + Display_Shapes_Draw_VLine(center_x-X, center_y-Y, 2*Y+1+Delta, 1, color); + Display_Shapes_Draw_VLine(center_x-Y, center_y-X, 2*X+1+Delta, 1, color); + } + } +} + +void Display_Shapes_Draw_Round_Rect_Frame(int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t radius, uint16_t thickness, Display_Color color) +{ + // Validate input parameters + if (width < 2 || height < 2 || thickness == 0) { + return; + } + + // Clamp radius to maximum possible value + uint16_t max_radius = ((width < height) ? width : height) / 2; + if (radius > max_radius) { + radius = max_radius; + } + + // For very small rectangles, just draw a filled rectangle + if (radius == 0 || width <= 2*radius || height <= 2*radius) { + Display_Shapes_Draw_Rect_Frame(x, y, width, height, thickness, color); + return; + } + + // Draw the straight edges (avoiding corners) + // Top edge + if (width > 2 * radius) { + Display_Shapes_Draw_HLine(x + radius, y, width - 2 * radius, thickness, color); + } + + // Bottom edge + if (width > 2 * radius) { + Display_Shapes_Draw_HLine(x + radius, y + height - thickness, width - 2 * radius, thickness, color); + } + + // Left edge + if (height > 2 * radius) { + Display_Shapes_Draw_VLine(x, y + radius, height - 2 * radius, thickness, color); + } + + // Right edge + if (height > 2 * radius) { + Display_Shapes_Draw_VLine(x + width - thickness, y + radius, height - 2 * radius, thickness, color); + } + + // Draw the four corner arcs with corrected positioning + Display_Shapes_Draw_Circle_Helper_Improved(x + radius, y + radius, radius, thickness, CORNER_TOP_LEFT, color); // Top-left corner + Display_Shapes_Draw_Circle_Helper_Improved(x + width - radius - 1, y + radius, radius, thickness, CORNER_TOP_RIGHT, color); // Top-right corner + Display_Shapes_Draw_Circle_Helper_Improved(x + width - radius - 1, y + height - radius - 1, radius, thickness, CORNER_BOTTOM_RIGHT, color); // Bottom-right corner + Display_Shapes_Draw_Circle_Helper_Improved(x + radius, y + height - radius - 1, radius, thickness, CORNER_BOTTOM_LEFT, color); // Bottom-left corner +} + +void Display_Shapes_Draw_Round_Rect_Filled(int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t radius, Display_Color color) +{ + uint16_t Max_Radius = ((width < height) ? width : height) / 2; // 1/2 minor axis + + if (radius > Max_Radius) + { + radius = Max_Radius; + } + + // Smarter Version + Display_Shapes_Draw_Rect_Filled(x + radius, y, width - 2 * radius, height, color); + + // Draw Four Corners + Display_Shapes_Draw_Circle_Helper_Filled(x + width - radius - 1 , y + radius, radius, 1, height - 2 * radius - 1, color); + Display_Shapes_Draw_Circle_Helper_Filled(x + radius , y + radius, radius, 2, height - 2 * radius - 1, color); +} + +void Display_Shapes_Draw_Arc_Frame(int16_t center_x, int16_t center_y, int16_t radius, uint16_t thickness, float angle_start, float angle_end, uint16_t steps, Display_Color color) +{ + if (thickness == 0 || radius == 0) { + return; + } + + // Normalize angles to 0-360 range + while (angle_start < 0.0f) angle_start += 360.0f; + while (angle_start >= 360.0f) angle_start -= 360.0f; + while (angle_end < 0.0f) angle_end += 360.0f; + while (angle_end >= 360.0f) angle_end -= 360.0f; + + // Handle case where arc crosses 0° boundary + while(angle_end < angle_start) { + angle_end += 360; + } + + if(steps == ARC_FRAME_AUTO_STEPS) + { + float Arc_Length = angle_end - angle_start; + steps = (uint16_t)(Arc_Length * 2.0f); // 2 Steps per Degree + + // Minimum steps for small arcs + if (steps < 8) { + steps = 8; + } + } + + float Angle_Step = (float)(angle_end - angle_start) / (float)steps; + + for (float i = angle_start; i <= angle_end; i = i + Angle_Step) + { + + if(thickness == 1) { + Display_Shapes_Draw_Pixel_Safe(center_x + cos(i*DEG2RAD) * radius, center_y + sin(i*DEG2RAD) * radius, color); + } + else { + Display_Shapes_Draw_Circle_Filled(center_x + cos(i*DEG2RAD) * radius, center_y + sin(i*DEG2RAD) * radius, thickness >> 1, color); + } + } +} + +void Display_Shapes_Draw_Glow_Circle(int16_t center_x, int16_t center_y, uint16_t radius, Display_Color core_color, Display_Color glow_color) +{ + // Draw a circle with a subtle glow effect + // Core circle with gradually fading outer ring + + if (radius == 0) { + return; + } + + // Define glow parameters + uint16_t Glow_Radius = radius + 4; // Glow extends 4 pixels beyond core + uint16_t Core_Radius = radius; + + // Draw glow layers from outside to inside for proper alpha blending effect + for (uint16_t Layer = Glow_Radius; Layer > Core_Radius; Layer--) { + // Calculate glow intensity based on distance from core + float Distance_From_Core = (float)(Layer - Core_Radius); + float Max_Glow_Distance = (float)(Glow_Radius - Core_Radius); + float Glow_Intensity = 1.0f - (Distance_From_Core / Max_Glow_Distance); + + // Apply easing curve for more natural glow falloff + Glow_Intensity = Glow_Intensity * Glow_Intensity; // Quadratic falloff + + // Blend glow color with background (assuming dark background) + Display_Color Layer_Color = Display_Color_Interpolate_Float( + Display_Objects_Background_Color_Get(), + glow_color, + Glow_Intensity * 0.3f // Max 30% glow intensity + ); + + // Draw this glow layer as a thin circle frame + Display_Shapes_Draw_Circle_Frame(center_x, center_y, Layer, 1, Layer_Color); + } + + // Draw the solid core circle + Display_Shapes_Draw_Circle_Filled(center_x, center_y, Core_Radius, core_color); + + // Add a subtle highlight for 3D effect (optional) + if (Core_Radius > 3) { + // Small highlight offset towards top-left + int16_t Highlight_X = center_x - (Core_Radius / 3); + int16_t Highlight_Y = center_y - (Core_Radius / 3); + uint16_t Highlight_Radius = Core_Radius / 3; + + Display_Color Highlight_Color = Display_Color_Interpolate_Float( + core_color, + DISPLAY_COLOR_WHITE, + 0.4f // 40% white blend for highlight + ); + + Display_Shapes_Draw_Circle_Filled(Highlight_X, Highlight_Y, Highlight_Radius, Highlight_Color); + } +} + +Coordinates Display_Shapes_Polar_To_XY(int16_t origin_x, int16_t origin_y, float angle, uint16_t radius) +{ + Coordinates Return_Value = { .X = origin_x, .Y = origin_y }; + + Return_Value.X += cos(angle * DEG2RAD) * radius; + Return_Value.Y += sin(angle * DEG2RAD) * radius; + + return Return_Value; +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ +/**************************************************************************/ +/*! + @brief Quarter-circle drawer, used to do circles and roundrects + @param x0 Center-point x coordinate + @param y0 Center-point y coordinate + @param r Radius of circle + @param cornername Mask bit #1 or bit #2 to indicate which quarters of the circle we're doing + @param color 16-bit 5-6-5 Color to draw with +*/ +/**************************************************************************/ +void Display_Shapes_Draw_Circle_Helper(int16_t x0, int16_t y0, uint16_t radius, uint16_t thickness, uint8_t cornername, Display_Color color) +{ + int16_t f = 1 - radius; + int16_t ddF_x = 1; + int16_t ddF_y = -2 * radius; + int16_t x = 0; + int16_t y = radius; + + while (x < y) + { + if (f >= 0) + { + y--; + ddF_y += 2; + f += ddF_y; + } + x++; + ddF_x += 2; + f += ddF_x; + + if (cornername & CORNER_BOTTOM_RIGHT) + { + Display_Shapes_Draw_Circle_Filled(x0 + x, y0 + y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(x0 + y, y0 + x, thickness >> 1, color); + } + + if (cornername & CORNER_TOP_RIGHT) + { + Display_Shapes_Draw_Circle_Filled(x0 + x, y0 - y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(x0 + y, y0 - x, thickness >> 1, color); + } + + if (cornername & CORNER_BOTTOM_LEFT) + { + Display_Shapes_Draw_Circle_Filled(x0 - x, y0 + y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(x0 - y, y0 + x, thickness >> 1, color); + } + + if (cornername & CORNER_TOP_LEFT) + { + Display_Shapes_Draw_Circle_Filled(x0 - x, y0 - y, thickness >> 1, color); + Display_Shapes_Draw_Circle_Filled(x0 - y, y0 - x, thickness >> 1, color); + } + } +} + +void Display_Shapes_Draw_Circle_Helper_Improved(int16_t x0, int16_t y0, uint16_t radius, uint16_t thickness, uint8_t cornername, Display_Color color) +{ + if (radius == 0) return; + + // For thickness of 1, use single pixel drawing + if (thickness == 1) { + Display_Shapes_Draw_Circle_Helper_Single_Pixel(x0, y0, radius, cornername, color); + return; + } + + // For thicker lines, draw multiple concentric quarter-circles + // This ensures consistent thickness with the straight edges + for (uint16_t t = 0; t < thickness; t++) { + uint16_t current_radius = radius - t; + if (current_radius == 0) break; + + Display_Shapes_Draw_Circle_Helper_Single_Pixel(x0, y0, current_radius, cornername, color); + } +} + +void Display_Shapes_Draw_Circle_Helper_Single_Pixel(int16_t x0, int16_t y0, uint16_t radius, uint8_t cornername, Display_Color color) +{ + if (radius == 0) return; + + // Use Bresenham's circle algorithm for single pixel drawing + int16_t f = 1 - radius; + int16_t ddF_x = 1; + int16_t ddF_y = -2 * radius; + int16_t x = 0; + int16_t y = radius; + + while (x < y) { + if (f >= 0) { + y--; + ddF_y += 2; + f += ddF_y; + } + x++; + ddF_x += 2; + f += ddF_x; + + // Draw quarter-circle segments based on corner mask - single pixels only + if (cornername & CORNER_TOP_LEFT) { + Display_Shapes_Draw_Pixel_Safe(x0 - x, y0 - y, color); + Display_Shapes_Draw_Pixel_Safe(x0 - y, y0 - x, color); + } + + if (cornername & CORNER_TOP_RIGHT) { + Display_Shapes_Draw_Pixel_Safe(0 + x, y0 - y, color); + Display_Shapes_Draw_Pixel_Safe(x0 + y, y0 - x, color); + } + + if (cornername & CORNER_BOTTOM_RIGHT) { + Display_Shapes_Draw_Pixel_Safe(x0 + x, y0 + y, color); + Display_Shapes_Draw_Pixel_Safe(x0 + y, y0 + x, color); + } + + if (cornername & CORNER_BOTTOM_LEFT) { + Display_Shapes_Draw_Pixel_Safe(x0 - x, y0 + y, color); + Display_Shapes_Draw_Pixel_Safe(x0 - y, y0 + x, color); + } + } +} + +/**************************************************************************/ +/*! + @brief Quarter-circle drawer with fill, used for circles and roundrects + @param x0 Center-point x coordinate + @param y0 Center-point y coordinate + @param r Radius of circle + @param corners Mask bits indicating which quarters we're doing + @param delta Offset from center-point, used for round-rects + @param color 16-bit 5-6-5 Color to fill with +*/ +/**************************************************************************/ +void Display_Shapes_Draw_Circle_Helper_Filled(int16_t x0, int16_t y0, uint16_t radius, uint8_t corners, int16_t delta, Display_Color color) +{ + int16_t f = 1 - radius; + int16_t ddF_x = 1; + int16_t ddF_y = -2 * radius; + int16_t x = 0; + int16_t y = radius; + int16_t px = x; + int16_t py = y; + + delta++; // Avoid some +1's in the loop + + while (x < y) + { + if (f >= 0) + { + y--; + ddF_y += 2; + f += ddF_y; + } + x++; + ddF_x += 2; + f += ddF_x; + + // These checks avoid double-drawing certain lines, important + // for the SSD1306 library which has an INVERT drawing mode. + if (x < (y + 1)) + { + if (corners & CORNER_TOP_LEFT) { + Display_Shapes_Draw_VLine(x0 + x, y0 - y, 2 * y + delta, 1, color); + // writeFastVLine(x0 + x, y0 - y, 2 * y + delta, color); + } + if (corners & CORNER_TOP_RIGHT) { + Display_Shapes_Draw_VLine(x0 - x, y0 - y, 2 * y + delta, 1, color); + // writeFastVLine(x0 - x, y0 - y, 2 * y + delta, color); + } + } + + if (y != py) + { + if (corners & CORNER_TOP_LEFT) { + Display_Shapes_Draw_VLine(x0 + py, y0 - px, 2 * px + delta, 1, color); + // writeFastVLine(x0 + py, y0 - px, 2 * px + delta, color); + } + if (corners & CORNER_TOP_RIGHT) { + Display_Shapes_Draw_VLine(x0 - py, y0 - px, 2 * px + delta, 1, color); + // writeFastVLine(x0 - py, y0 - px, 2 * px + delta, color); + } + py = y; + } + px = x; + } +} \ No newline at end of file diff --git a/Firmware/Display_Shapes.h b/Firmware/Display_Shapes.h new file mode 100644 index 0000000..20b5eab --- /dev/null +++ b/Firmware/Display_Shapes.h @@ -0,0 +1,47 @@ +/* + * Display_Shapes.h + * + * Created: Mon Jul 19 2021 17:55:37 + * Author Chris + */ +#ifndef DISPLAY_SHAPES_H_ +#define DISPLAY_SHAPES_H_ + +// ============================================================================================ +// Includes +#include "Display_Config.h" +#include "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Defines +#define ARC_FRAME_AUTO_STEPS 0 + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Display_Shapes_Init (Display_Image_Buffer** current_buffer); +void Display_Shapes_Fill_Screen (Display_Color color); +void Display_Shapes_Draw_Pixel_Safe (int16_t x, int16_t y, Display_Color color); +void Display_Shapes_Draw_HLine (int16_t x, int16_t y, uint16_t width, uint16_t thickness, Display_Color color); +void Display_Shapes_Draw_VLine (int16_t x, int16_t y, uint16_t height, uint16_t thickness, Display_Color color); +void Display_Shapes_Draw_Line_XY (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t thickness, Display_Color color); +void Display_Shapes_Draw_Line_Rad (int16_t x, int16_t y, float angle, uint16_t radius_start, uint16_t radius_end, uint16_t thickness, Display_Color color); +void Display_Shapes_Draw_Rect_Frame (int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t thickness, Display_Color color); +void Display_Shapes_Draw_Rect_Filled (int16_t x, int16_t y, uint16_t width, uint16_t height, Display_Color color); +void Display_Shapes_Draw_Circle_Frame (int16_t center_x, int16_t center_y, uint16_t radius, uint16_t thickness, Display_Color color); +void Display_Shapes_Draw_Circle_Filled (int16_t center_x, int16_t center_y, uint16_t radius, Display_Color color); +void Display_Shapes_Draw_Round_Rect_Frame (int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t radius, uint16_t thickness, Display_Color color); +void Display_Shapes_Draw_Round_Rect_Filled (int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t radius, Display_Color color); +void Display_Shapes_Draw_Arc_Frame (int16_t center_x, int16_t center_y, int16_t radius, uint16_t thickness, float angle_start, float angle_end, uint16_t steps, Display_Color color); + +void Display_Shapes_Draw_Glow_Circle (int16_t center_x, int16_t center_y, uint16_t radius, Display_Color core_color, Display_Color glow_color); + +Coordinates Display_Shapes_Polar_To_XY (int16_t origin_x, int16_t origin_y, float angle, uint16_t radius); + + +#endif /* DISPLAY_SHAPES_H_ */ diff --git a/Firmware/Display_Touch.c b/Firmware/Display_Touch.c new file mode 100644 index 0000000..b98daa3 --- /dev/null +++ b/Firmware/Display_Touch.c @@ -0,0 +1,532 @@ +/* + * Display_Touch.c + * + * Created: Mon Jun 05 2023 2:39:04 PM + * Author: MrChros + */ +// ============================================================================================ +// Includes +#include "Display_Touch.h" + +#include "hardware/divider.h" + +#include "Display.h" +#include "Display_SPI.h" +#include "Display_Config.h" + + +// ============================================================================================ +// Defines +///////////////////////////////// +// Touch Communication Defines // +///////////////////////////////// +#define DISPLAY_TOUCH_SPI_BAUDRATE 2000000 + +#define DISPLAY_TOUCH_MUX_X 1 +#define DISPLAY_TOUCH_MUX_Y 5 +#define DISPLAY_TOUCH_MUX_Z1 3 +#define DISPLAY_TOUCH_MUX_Z2 4 + +#define DISPLAY_TOUCH_RES_12BIT 1 +#define DISPLAY_TOUCH_RES_8BIT 0 + +#define ACQ_MODE_DIFF 0 +#define ACQ_MODE_SINGLE 1 + +#define SHIFT_START_BIT 7 +#define SHIFT_MULTIPLEXER 4 +#define SHIFT_RESOLUTION 3 +#define SHIFT_ACQ_MODE 2 +#define SHIFT_PD_REFERENCE 1 // PD = Power-Down +#define SHIFT_PD_ADC 0 // PD = Power-Down + +#define OFF 0 +#define ON 1 + +/////////////////////////////// +// Touch Calculation Defines // +/////////////////////////////// +#define POINT_TOUCH_REFERENCE_OFFSET 30 +#define POINT_TOUCH_REFERECE_COUNT 2 + + +/////////////////////////// +// Touch Marking Defines // +/////////////////////////// +#define TOUCH_MARKER_COUNT 100 +#define TOUCH_MARKER_DEFAULT_TICKS 50 + + +// ============================================================================================ +// Variables +static uint _X; +static uint _Y; +static uint _Z1; +static uint _Z2; +static float _Pressure; + +static uint _Baudrate_Backup; +static bool _Display_Currently_Touched; + +typedef struct { + Coordinates Coordinates_Screen; + Coordinates Coordinates_Touch; +} Touch_Reference_Point_s; +static Touch_Reference_Point_s _Touch_Reference_Points[POINT_TOUCH_REFERECE_COUNT]; + +typedef struct { + float Slope; + float Intersect; +} Touch_Conversion_Factor_s; +static Touch_Conversion_Factor_s _Touch_Conversion_Factors[POINT_TOUCH_REFERECE_COUNT]; + +typedef struct { + Coordinates Coordinates; + uint Tick_Duration; +} Touch_Marker_s; + +typedef struct { + Touch_Marker_s Marker[TOUCH_MARKER_COUNT]; + uint Fill_Count; + uint Read_Start; + uint Write_Next; +} Touch_Marker_Buffer_s; +static Touch_Marker_Buffer_s _Touch_Marker_Buffer; + +// ============================================================================================ +// Function Declarations +void Display_Touch_Marker_Add(int16_t x, int16_t y); +void Display_Touch_Marker_Tick(void); + +int16_t Display_Touch_Get_Screen_X_From_Touch_X(uint x_touch); +int16_t Display_Touch_Get_Screen_Y_From_Touch_Y(uint y_touch); +void Display_Touch_Update_Conversion_Factors(void); +bool Display_Touch_Is_Touched(); + +bool Display_Touch_Read_Sequential(uint times_read_each_value); +bool Display_Touch_Read_Overlapping(uint average_of_measurements); +bool Display_Touch_Read_X(); +bool Display_Touch_Read_Y(); +bool Display_Touch_Read_Z1(); +bool Display_Touch_Read_Z2(); +bool Display_Touch_Read_Single_Parameter(uint mux, uint resolution, uint8_t *data); + +uint8_t Display_Touch_Get_Control_Byte(uint mux, uint resolution); +uint Display_Touch_Assemble_Value(uint8_t byte_low, uint8_t byte_high); + +static inline void Display_Touch_SPI_CS_Select(); +static inline void Display_Touch_SPI_CS_Deselect(); + + +/******************************************************************* + Interrupt Service Routines +*******************************************************************/ + + +/******************************************************************* + Functions +*******************************************************************/ +void Display_Touch_Init() +{ + _X = 0; + _Y = 0; + _Z1 = 0; + _Z2 = 0; + _Pressure = 0; + + _Display_Currently_Touched = false; + + + // Set Reference Point to be shown on Screen and used for later calculations + _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Screen.X = POINT_TOUCH_REFERENCE_OFFSET; + _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Screen.Y = POINT_TOUCH_REFERENCE_OFFSET; + + _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT].Coordinates_Screen.X = DISPLAY_WIDTH - POINT_TOUCH_REFERENCE_OFFSET; + _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT].Coordinates_Screen.Y = DISPLAY_HEIGHT - POINT_TOUCH_REFERENCE_OFFSET; + + Display_Touch_Set_Reference_Point(DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT , 0, 0); + Display_Touch_Set_Reference_Point(DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT, 1, 1); + + // Prefill corresponding Touch coordinates + // Later to be read from a non-volatile memory + Display_Touch_Set_Reference_Point(DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT , 720, 3376); + Display_Touch_Set_Reference_Point(DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT, 3616, 656); + + Display_Touch_Update_Conversion_Factors(); + + + _Touch_Marker_Buffer.Fill_Count = 0; + _Touch_Marker_Buffer.Read_Start = 0; + _Touch_Marker_Buffer.Write_Next = 0; + for(int i=0;i= POINT_TOUCH_REFERECE_COUNT) { + return; + } + + _Touch_Reference_Points[point].Coordinates_Touch.X = x_touch; + _Touch_Reference_Points[point].Coordinates_Touch.Y = y_touch; +} + +void Display_Touch_Detect(uint average_of_measurements) +{ + bool Success; + + Display_Touch_Marker_Tick(); + + Success = Display_Touch_Read_Overlapping(average_of_measurements); + // Success = Display_Touch_Read_Sequential(average_of_measurements); + + if(Success == false) { + return; + } + + if(Display_Touch_Is_Touched() == true) { + int16_t X_Screen = Display_Touch_Get_Screen_X_From_Touch_X(_X); + int16_t Y_Screen = Display_Touch_Get_Screen_Y_From_Touch_Y(_Y); + + if(X_Screen>=0 && X_Screen=0 && Y_Screen= Display_Touch_Get_Reference_Point_Count()) { + return NULL; + } + + return &(_Touch_Reference_Points[point_number].Coordinates_Screen); +} + +uint Display_Touch_Get_Marker_Count() +{ + return _Touch_Marker_Buffer.Fill_Count; +} + +Coordinates* Display_Touch_Get_Marker_Coordinates(uint index) +{ + if(index >= TOUCH_MARKER_COUNT) { + return NULL; + } + + index += _Touch_Marker_Buffer.Read_Start; + + while(index >= TOUCH_MARKER_COUNT) { + index -= TOUCH_MARKER_COUNT; + } + + return &(_Touch_Marker_Buffer.Marker[index].Coordinates); +} + +uint Display_Touch_Get_Last_X() +{ + return _X; +} + +uint Display_Touch_Get_Last_Y() +{ + return _Y; +} + +uint Display_Touch_Get_Last_Z1() +{ + return _Z1; +} + +uint Display_Touch_Get_Last_Z2() +{ + return _Z2; +} + +float Display_Touch_Get_Last_Pressure() +{ + return _Pressure; +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ +void Display_Touch_Marker_Add(int16_t x, int16_t y) +{ + _Touch_Marker_Buffer.Marker[_Touch_Marker_Buffer.Write_Next].Coordinates.X = x; + _Touch_Marker_Buffer.Marker[_Touch_Marker_Buffer.Write_Next].Coordinates.Y = y; + _Touch_Marker_Buffer.Marker[_Touch_Marker_Buffer.Write_Next].Tick_Duration = TOUCH_MARKER_DEFAULT_TICKS; + + _Touch_Marker_Buffer.Write_Next++; + if(_Touch_Marker_Buffer.Write_Next >= TOUCH_MARKER_COUNT) { + _Touch_Marker_Buffer.Write_Next = 0; + } + + if(_Touch_Marker_Buffer.Fill_Count < TOUCH_MARKER_COUNT) { + _Touch_Marker_Buffer.Fill_Count++; + } +} + +void Display_Touch_Marker_Tick(void) +{ + uint Fill_Count = _Touch_Marker_Buffer.Fill_Count; + uint Read_Start = _Touch_Marker_Buffer.Read_Start; + + for(uint i=0;i= TOUCH_MARKER_COUNT) { + Index -= TOUCH_MARKER_COUNT; + } + + if(_Touch_Marker_Buffer.Marker[Index].Tick_Duration > 0) { + _Touch_Marker_Buffer.Marker[Index].Tick_Duration--; + + if(_Touch_Marker_Buffer.Marker[Index].Tick_Duration==0 && i==0) { + _Touch_Marker_Buffer.Read_Start++; + _Touch_Marker_Buffer.Fill_Count--; + } + + if(_Touch_Marker_Buffer.Read_Start >= TOUCH_MARKER_COUNT) { + _Touch_Marker_Buffer.Read_Start = 0; + } + } + } +} + +int16_t Display_Touch_Get_Screen_X_From_Touch_X(uint x_touch) +{ + return (int16_t)(_Touch_Conversion_Factors[0].Slope * x_touch + _Touch_Conversion_Factors[0].Intersect); +} + +int16_t Display_Touch_Get_Screen_Y_From_Touch_Y(uint y_touch) +{ + return (int16_t)(_Touch_Conversion_Factors[1].Slope * y_touch + _Touch_Conversion_Factors[1].Intersect); +} + +void Display_Touch_Update_Conversion_Factors(void) +{ + const uint X = 0; + const uint Y = 1; + + float Y_Diff = (float)(_Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT].Coordinates_Screen.X - _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Screen.X); + float X_Diff = (float)(_Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT].Coordinates_Touch.X - _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Touch.X); + + float Slope = Y_Diff / X_Diff; + float Intersect = _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Screen.X - (Slope * _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Touch.X); + + _Touch_Conversion_Factors[X].Slope = Slope; + _Touch_Conversion_Factors[X].Intersect = Intersect; + + + Y_Diff = (float)(_Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT].Coordinates_Screen.Y - _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Screen.Y); + X_Diff = (float)(_Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT].Coordinates_Touch.Y - _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Touch.Y); + + Slope = Y_Diff / X_Diff; + Intersect = _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Screen.Y - (Slope * _Touch_Reference_Points[DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT].Coordinates_Touch.Y); + + _Touch_Conversion_Factors[Y].Slope = Slope; + _Touch_Conversion_Factors[Y].Intersect = Intersect; +} + +bool Display_Touch_Is_Touched() +{ + return (_Y > 0) && (_Z1 > 0); +} + +bool Display_Touch_Read_Sequential(uint times_read_each_value) +{ + if(times_read_each_value < 1) { + return false; + } + + _Baudrate_Backup = Display_SPI_Get_Baudrate(); + Display_SPI_Set_Baudrate(DISPLAY_TOUCH_SPI_BAUDRATE); + + for(int i=0;i> 12)) * (float)((((float)_Z2) / ((float)_Z1)) - 1); + + return true; +} + +bool Display_Touch_Read_Overlapping(uint average_of_measurements) +{ + if(average_of_measurements < 1) { + return false; + } + + uint8_t Write_Data[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + uint8_t Read_Data[9]; + + Write_Data[0] = Display_Touch_Get_Control_Byte(DISPLAY_TOUCH_MUX_X, DISPLAY_TOUCH_RES_12BIT); + Write_Data[2] = Display_Touch_Get_Control_Byte(DISPLAY_TOUCH_MUX_Y, DISPLAY_TOUCH_RES_12BIT); + Write_Data[4] = Display_Touch_Get_Control_Byte(DISPLAY_TOUCH_MUX_Z1, DISPLAY_TOUCH_RES_12BIT); + Write_Data[6] = Display_Touch_Get_Control_Byte(DISPLAY_TOUCH_MUX_Z2, DISPLAY_TOUCH_RES_12BIT); + + + _Baudrate_Backup = Display_SPI_Get_Baudrate(); + Display_SPI_Set_Baudrate(DISPLAY_TOUCH_SPI_BAUDRATE); + + uint X = 0; + uint Y = 0; + uint Z1 = 0; + uint Z2 = 0; + bool Success; + + for(int i=0;i> 12)) * (float)((((float)_Z2) / ((float)_Z1)) - 1); + } + + return Success; +} + +bool Display_Touch_Read_X() +{ + uint8_t Read_Data[3]; + bool Success = Display_Touch_Read_Single_Parameter(DISPLAY_TOUCH_MUX_X, DISPLAY_TOUCH_RES_12BIT, Read_Data); + + _X = Display_Touch_Assemble_Value(Read_Data[2], Read_Data[1]); + + return Success; +} + +bool Display_Touch_Read_Y() +{ + uint8_t Read_Data[3]; + bool Success = Display_Touch_Read_Single_Parameter(DISPLAY_TOUCH_MUX_Y, DISPLAY_TOUCH_RES_12BIT, Read_Data); + + _Y = Display_Touch_Assemble_Value(Read_Data[2], Read_Data[1]); + + return Success; +} + +bool Display_Touch_Read_Z1() +{ + uint8_t Read_Data[3]; + bool Success = Display_Touch_Read_Single_Parameter(DISPLAY_TOUCH_MUX_Z1, DISPLAY_TOUCH_RES_12BIT, Read_Data); + + _Z1 = Display_Touch_Assemble_Value(Read_Data[2], Read_Data[1]); + + return Success; +} + +bool Display_Touch_Read_Z2() +{ + uint8_t Read_Data[3]; + bool Success = Display_Touch_Read_Single_Parameter(DISPLAY_TOUCH_MUX_Z2, DISPLAY_TOUCH_RES_12BIT, Read_Data); + + _Z2 = Display_Touch_Assemble_Value(Read_Data[2], Read_Data[1]); + + return Success; +} + +bool Display_Touch_Read_Single_Parameter(uint mux, uint resolution, uint8_t *data) +{ + uint8_t Write_Data[3] = { 0, 0, 0 }; + Write_Data[0] = Display_Touch_Get_Control_Byte(mux, resolution); + + Display_Touch_SPI_CS_Select(); + bool Success = Display_SPI_Read_Write(Write_Data, data, sizeof(Write_Data)); + Display_Touch_SPI_CS_Deselect(); + + return Success; +} + +uint8_t Display_Touch_Get_Control_Byte(uint mux, uint resolution) +{ + return (uint8_t)( (ON) << SHIFT_START_BIT | // Set Start Bit to '1' + (mux & 0x07) << SHIFT_MULTIPLEXER | // Set A2 - A0 + (resolution & 0x01) << SHIFT_RESOLUTION | // Set Resolution (0 == 12 Bit / 1 == 8 Bit) + (ACQ_MODE_DIFF) << SHIFT_ACQ_MODE | // Differential Mode | .... Obsolete: Single Ended only + (OFF) << SHIFT_PD_REFERENCE | // Internal Reference Voltage OFF + (ON) << SHIFT_PD_ADC); // ADC ON +} + +uint Display_Touch_Assemble_Value(uint8_t byte_low, uint8_t byte_high) +{ + return (((uint)byte_high) << 5) | (byte_low >> 3); +} + +static inline void Display_Touch_SPI_CS_Select() +{ + asm volatile("nop \n nop \n nop"); + gpio_put(DISPLAY_SPI_PIN_CS_TOUCH, 0); // Active low + asm volatile("nop \n nop \n nop"); +} + +static inline void Display_Touch_SPI_CS_Deselect() +{ + asm volatile("nop \n nop \n nop"); + gpio_put(DISPLAY_SPI_PIN_CS_TOUCH, 1); + asm volatile("nop \n nop \n nop"); +} diff --git a/Firmware/Display_Touch.h b/Firmware/Display_Touch.h new file mode 100644 index 0000000..8feba6d --- /dev/null +++ b/Firmware/Display_Touch.h @@ -0,0 +1,50 @@ +/* + * Display_Touch.h + * + * Created: Mon Jun 05 2023 2:38:44 PM + * Author: MrChros + */ +#ifndef DISPLAY_TOUCH_H_ +#define DISPLAY_TOUCH_H_ + +// ============================================================================================ +// Includes +#include +#include +#include + +#include "pico/types.h" + +#include "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Defines +#define DISPLAY_TOUCH_REFERENCE_POINT_TOP_LEFT 0 +#define DISPLAY_TOUCH_REFERENCE_POINT_BOTTOM_RIGHT 1 + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Display_Touch_Init(); +void Display_Touch_Set_Reference_Point(uint point, uint x_touch, uint y_touch); +void Display_Touch_Detect(uint average_of_measurements); + +int Display_Touch_Get_Reference_Point_Count(); +Coordinates* Display_Touch_Get_Reference_Point(int point_number); + +uint Display_Touch_Get_Marker_Count(); +Coordinates* Display_Touch_Get_Marker_Coordinates(uint index); + +uint Display_Touch_Get_Last_X(); +uint Display_Touch_Get_Last_Y(); +uint Display_Touch_Get_Last_Z1(); +uint Display_Touch_Get_Last_Z2(); +float Display_Touch_Get_Last_Pressure(); + + +#endif /* DISPLAY_TOUCH_H_ */ diff --git a/Firmware/Easings.c b/Firmware/Easings.c new file mode 100644 index 0000000..fc7ef21 --- /dev/null +++ b/Firmware/Easings.c @@ -0,0 +1,271 @@ +/* + * Easings.c + * + * Created: Sun Jun 22 2025 15:52:12 + * Author Chris + */ +#include "Easings.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ +float Linear(float x) +{ + if(x <= 1.0f) { + return x; + } + + return 1.0f; +} + +float Ease_In_Sine(float x) +{ + if(x <= 1.0f) { + return (float)( 1 - cosf((x * M_PI) / 2.0f)); + } + + return 1.0f; +} + +float Ease_Out_Sine(float x) +{ + if(x <= 1.0f) { + return (float)(sinf((x * M_PI) / 2.0f)); + } + + return 1.0f; +} + +float Ease_InOut_Sine(float x) +{ + if(x <= 1.0f) { + return (float)(-(cosf(M_PI * x) - 1.0) / 2.0); + } + + return 1.0f; +} + +float Ease_In_Quad(float x) +{ + if(x <= 1.0f) { + return x * x; + } + + return 1.0f; +} + +float Ease_Out_Quad(float x) +{ + if(x <= 1.0f) { + return 1 - (1 - x) * (1 - x); + } + + return 1.0f; +} + +float Ease_InOut_Quad(float x) +{ + if(x <= 1.0f) { + return (float)(x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2); + } + + return 1.0f; +} + +float Ease_In_Cubic(float x) +{ + if(x <= 1.0f) { + return x * x * x; + } + + return 1.0f; +} + +float Ease_Out_Cubic(float x) +{ + if(x <= 1.0f) { + return (float)(1 - pow(1 - x, 3)); + } + + return 1.0f; +} + +float Ease_InOut_Cubic(float x) +{ + if(x <= 1.0f) { + return (float)(x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2); + } + + return 1.0f; +} + + +float Ease_In_Quart(float x) +{ + if(x <= 1.0f) { + return x * x * x * x; + } + + return 1.0f; +} + +float Ease_Out_Quart(float x) +{ + if(x <= 1.0f) { + return (float)(1 - pow(1 - x, 4)); + } + + return 1.0f; +} + +float Ease_InOut_Quart(float x) +{ + if(x <= 1.0f) { + return (float)(x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2); + } + + return 1.0f; +} + + +float Ease_In_Quint(float x) +{ + if(x <= 1.0f) { + return x * x * x * x * x; + } + + return 1.0f; +} + +float Ease_Out_Quint(float x) +{ + if(x <= 1.0f) { + return (float)(1 - pow(1 - x, 5)); + } + + return 1.0f; +} + +float Ease_InOut_Quint(float x) +{ + if(x <= 1.0f) { + return (float)(x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2); + } + + return 1.0f; +} + + +float Ease_In_Expo(float x) +{ + if(x <= 1.0f) { + return (float)(x == 0 ? 0 : pow(2, 10 * x - 10)); + } + + return 1.0f; +} + +float Ease_Out_Expo(float x) +{ + if(x <= 1.0f) { + return (float)(x == 1 ? 1 : 1 - pow(2, -10 * x)); + } + + return 1.0f; +} + +float Ease_InOut_Expo(float x) +{ + if(x <= 1.0f) { + return (float)(x == 0 + ? 0 + : x == 1 + ? 1 + : x < 0.5 ? pow(2, 20 * x - 10) / 2 + : (2 - pow(2, -20 * x + 10)) / 2); + } + + return 1.0f; +} + + +float Ease_In_Circ(float x) +{ + if(x <= 1.0f) { + return (float)(1 - sqrt(1 - pow(x, 2))); + } + + return 1.0f; +} + +float Ease_Out_Circ(float x) +{ + if(x <= 1.0f) { + return (float)(sqrt(1 - pow(x - 1, 2))); + } + + return 1.0f; +} + +float Ease_InOut_Circ(float x) +{ + if(x <= 1.0f) { + return (float)(x < 0.5 + ? (1 - sqrt(1 - pow(2 * x, 2))) / 2 + : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2); + } + + return 1.0f; +} + +float ApplyEasing2(float ratio, float value1, float value2, Easing easing) +{ + return value1 + (value2 - value1) * ApplyEasing1(ratio, easing); +} + +float ApplyEasing1(float ratio, Easing easing) +{ + switch (easing) + { + case LINEAR: return Linear(ratio); + case IN_SINE: return Ease_In_Sine(ratio); + case IN_QUAD: return Ease_In_Quad(ratio); + case IN_CUBIC: return Ease_In_Cubic(ratio); + case IN_QUART: return Ease_In_Quart(ratio); + case IN_QUINT: return Ease_In_Quint(ratio); + case IN_EXPO: return Ease_In_Expo(ratio); + case IN_CIRC: return Ease_In_Circ(ratio); + case OUT_SINE: return Ease_Out_Sine(ratio); + case OUT_QUAD: return Ease_Out_Quad(ratio); + case OUT_CUBIC: return Ease_Out_Cubic(ratio); + case OUT_QUART: return Ease_Out_Quart(ratio); + case OUT_QUINT: return Ease_Out_Quint(ratio); + case OUT_EXPO: return Ease_Out_Expo(ratio); + case OUT_CIRC: return Ease_Out_Circ(ratio); + case INOUT_SINE: return Ease_InOut_Sine(ratio); + case INOUT_QUAD: return Ease_InOut_Quad(ratio); + case INOUT_CUBIC: return Ease_InOut_Cubic(ratio); + case INOUT_QUART: return Ease_InOut_Quart(ratio); + case INOUT_QUINT: return Ease_InOut_Quint(ratio); + case INOUT_EXPO: return Ease_InOut_Expo(ratio); + case INOUT_CIRC: return Ease_InOut_Circ(ratio); + } + + return Linear(ratio); +} +/******************************************************************* + Internal Functions +*******************************************************************/ \ No newline at end of file diff --git a/Firmware/Easings.h b/Firmware/Easings.h new file mode 100644 index 0000000..b747d1c --- /dev/null +++ b/Firmware/Easings.h @@ -0,0 +1,80 @@ +/* + * Easings.h + * + * Created: Sun Jun 22 2025 15:51:51 + * Author Chris + */ +#ifndef EASINGS_H_ +#define EASINGS_H_ + +// ============================================================================================ +// Includes +#include +#include +#include +#include + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes +typedef enum +{ + LINEAR, + IN_SINE, + IN_QUAD, + IN_CUBIC, + IN_QUART, + IN_QUINT, + IN_EXPO, + IN_CIRC, + OUT_SINE, + OUT_QUAD, + OUT_CUBIC, + OUT_QUART, + OUT_QUINT, + OUT_EXPO, + OUT_CIRC, + INOUT_SINE, + INOUT_QUAD, + INOUT_CUBIC, + INOUT_QUART, + INOUT_QUINT, + INOUT_EXPO, + INOUT_CIRC +} Easing; + + +// ============================================================================================ +// Function Declarations +float Linear(float x); +float Ease_In_Sine(float x); +float Ease_Out_Sine(float x); +float Ease_InOut_Sine(float x); +float Ease_In_Quad(float x); +float Ease_Out_Quad(float x); +float Ease_InOut_Quad(float x); +float Ease_In_Cubic(float x); +float Ease_Out_Cubic(float x); +float Ease_InOut_Cubic(float x); +float Ease_In_Quart(float x); +float Ease_Out_Quart(float x); +float Ease_InOut_Quart(float x); +float Ease_In_Quint(float x); +float Ease_Out_Quint(float x); +float Ease_InOut_Quint(float x); +float Ease_In_Expo(float x); +float Ease_Out_Expo(float x); +float Ease_InOut_Expo(float x); +float Ease_In_Circ(float x); +float Ease_Out_Circ(float x); +float Ease_InOut_Circ(float x); + +float ApplyEasing2(float ratio, float value1, float value2, Easing easing); +float ApplyEasing1(float ratio, Easing easing); + + +#endif /* EASINGS_H_ */ \ No newline at end of file diff --git a/Firmware/Fonts/Font_DejaVu_Sans_Mono_10x17.c b/Firmware/Fonts/Font_DejaVu_Sans_Mono_10x17.c new file mode 100644 index 0000000..02a6cb7 --- /dev/null +++ b/Firmware/Fonts/Font_DejaVu_Sans_Mono_10x17.c @@ -0,0 +1,109 @@ +#include + +const uint8_t _Font_DejaVu_Sans_Mono_10x17[] = { + 0x00, 0x00, // Size of zero indicates fixed width font, actual length is width * height + 0x0a, // Width + 0x11, // Height + 0x20, // First Character + 0x5f, // Character Count + + // Fixed width; char width table not used !!!! + + // Font Data + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ! + 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // " + 0x00, 0x20, 0x20, 0xe0, 0x3c, 0x20, 0xe0, 0x7c, 0x24, 0x20, 0x02, 0x12, 0x1e, 0x03, 0x02, 0x1e, 0x07, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // # + 0x00, 0x00, 0x70, 0x98, 0x88, 0xfe, 0x08, 0x08, 0x10, 0x00, 0x00, 0x00, 0x08, 0x10, 0x10, 0x7f, 0x11, 0x11, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // $ + 0x1c, 0x22, 0x22, 0xa2, 0x9c, 0x40, 0x40, 0x20, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // % + 0x00, 0x80, 0xdc, 0x22, 0xc2, 0x82, 0x02, 0x00, 0x80, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x11, 0x1e, 0x0c, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // & + 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ' + 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x38, 0x60, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ( + 0x00, 0x00, 0x02, 0x06, 0x1c, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x60, 0x38, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ) + 0x00, 0x48, 0x50, 0x30, 0xfe, 0x30, 0x50, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // * + 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x78, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // , + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // - + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // . + 0x00, 0x00, 0x00, 0x00, 0xc0, 0x30, 0x0c, 0x02, 0x00, 0x00, 0x00, 0x20, 0x18, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // / + 0x00, 0xf0, 0x0c, 0x02, 0xc2, 0xc2, 0x02, 0x0c, 0xf0, 0x00, 0x00, 0x03, 0x0c, 0x10, 0x10, 0x10, 0x10, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0 + 0x00, 0x00, 0x04, 0x06, 0x02, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x1f, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1 + 0x00, 0x0c, 0x06, 0x02, 0x02, 0x02, 0x82, 0x44, 0x38, 0x00, 0x00, 0x10, 0x18, 0x1c, 0x12, 0x11, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2 + 0x00, 0x04, 0x02, 0x42, 0x42, 0x42, 0x42, 0xa4, 0x38, 0x00, 0x00, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3 + 0x00, 0x00, 0xc0, 0x30, 0x1c, 0x06, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x1f, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 4 + 0x00, 0x00, 0x7e, 0x22, 0x22, 0x22, 0x22, 0x42, 0x80, 0x00, 0x00, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 5 + 0x00, 0xf0, 0x4c, 0x26, 0x22, 0x22, 0x22, 0x44, 0x80, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 6 + 0x00, 0x02, 0x02, 0x02, 0x02, 0x82, 0x62, 0x1a, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 7 + 0x00, 0x3c, 0xa4, 0x42, 0x42, 0x42, 0x42, 0xa4, 0xbc, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8 + 0x00, 0x78, 0x84, 0x02, 0x02, 0x02, 0x02, 0x84, 0xf8, 0x00, 0x00, 0x00, 0x08, 0x11, 0x11, 0x11, 0x19, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 9 + 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // : + 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x78, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ; + 0x00, 0x80, 0x80, 0xc0, 0x40, 0x60, 0x20, 0x20, 0x30, 0x00, 0x00, 0x01, 0x01, 0x03, 0x02, 0x06, 0x04, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // < + 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // = + 0x00, 0x30, 0x20, 0x20, 0x60, 0x40, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x0c, 0x04, 0x04, 0x06, 0x02, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // > + 0x00, 0x00, 0x04, 0x02, 0x82, 0x42, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ? + 0x00, 0xc0, 0x30, 0x08, 0xc4, 0x64, 0x24, 0x6c, 0xf8, 0x00, 0x00, 0x0f, 0x30, 0x40, 0x8f, 0x98, 0x90, 0x98, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // @ + 0x00, 0x00, 0x80, 0x78, 0x0e, 0x0e, 0x78, 0x80, 0x00, 0x00, 0x00, 0x18, 0x07, 0x02, 0x02, 0x02, 0x02, 0x07, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // A + 0x00, 0xfe, 0x42, 0x42, 0x42, 0x42, 0x42, 0xa4, 0xbc, 0x00, 0x00, 0x1f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // B + 0x00, 0xf0, 0x0c, 0x04, 0x02, 0x02, 0x02, 0x06, 0x04, 0x00, 0x00, 0x03, 0x0c, 0x08, 0x10, 0x10, 0x10, 0x18, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // C + 0x00, 0xfe, 0x02, 0x02, 0x02, 0x02, 0x04, 0x0c, 0xf0, 0x00, 0x00, 0x1f, 0x10, 0x10, 0x10, 0x10, 0x08, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // D + 0x00, 0xfe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x1f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // E + 0x00, 0xfe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x02, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // F + 0x00, 0xf0, 0x0c, 0x04, 0x02, 0x02, 0x82, 0x86, 0x84, 0x00, 0x00, 0x03, 0x0c, 0x08, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // G + 0x00, 0xfe, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0xfe, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // H + 0x00, 0x00, 0x02, 0x02, 0xfe, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x1f, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // I + 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0xfe, 0x00, 0x00, 0x00, 0x08, 0x18, 0x10, 0x10, 0x10, 0x18, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // J + 0x00, 0xfe, 0x40, 0x20, 0xd0, 0x08, 0x04, 0x02, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x01, 0x06, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // K + 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // L + 0x00, 0xfe, 0x0e, 0x38, 0xc0, 0xc0, 0x38, 0x0e, 0xfe, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // M + 0x00, 0xfe, 0x06, 0x18, 0x60, 0x80, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x01, 0x06, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // N + 0x00, 0xf8, 0x0c, 0x02, 0x02, 0x02, 0x02, 0x0c, 0xf8, 0x00, 0x00, 0x07, 0x0c, 0x10, 0x10, 0x10, 0x10, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // O + 0x00, 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // P + 0x00, 0xf8, 0x0c, 0x02, 0x02, 0x02, 0x02, 0x0c, 0xf0, 0x00, 0x00, 0x07, 0x0c, 0x10, 0x10, 0x10, 0x30, 0x7c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Q + 0x00, 0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x44, 0x78, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // R + 0x00, 0x38, 0x44, 0x42, 0xc2, 0x82, 0x86, 0x84, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x10, 0x10, 0x10, 0x10, 0x08, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // S + 0x02, 0x02, 0x02, 0x02, 0xfe, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // T + 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // U + 0x00, 0x06, 0x78, 0x80, 0x00, 0x00, 0x80, 0x78, 0x06, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1c, 0x1c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // V + 0x0e, 0xf0, 0x00, 0x00, 0xf0, 0xf0, 0x00, 0x00, 0xf0, 0x0e, 0x00, 0x07, 0x18, 0x07, 0x00, 0x00, 0x07, 0x18, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // W + 0x00, 0x02, 0x0c, 0x30, 0xc0, 0xc0, 0x30, 0x0c, 0x02, 0x00, 0x00, 0x10, 0x0c, 0x03, 0x00, 0x00, 0x03, 0x0c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // X + 0x02, 0x04, 0x18, 0x60, 0x80, 0x60, 0x18, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Y + 0x00, 0x02, 0x02, 0x02, 0x82, 0x62, 0x32, 0x0a, 0x06, 0x00, 0x00, 0x18, 0x14, 0x13, 0x11, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Z + 0x00, 0x00, 0x00, 0x00, 0xfe, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // [ + 0x00, 0x02, 0x0c, 0x30, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06, 0x18, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // "\" + 0x00, 0x00, 0x00, 0x02, 0x02, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ] + 0x00, 0x10, 0x18, 0x0c, 0x06, 0x02, 0x06, 0x0c, 0x18, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ^ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // _ + 0x00, 0x00, 0x01, 0x03, 0x06, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ` + 0x00, 0x00, 0x20, 0x90, 0x90, 0x90, 0x90, 0xb0, 0xe0, 0x00, 0x00, 0x0f, 0x19, 0x10, 0x10, 0x10, 0x18, 0x0c, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // a + 0x00, 0xfe, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0xc0, 0x00, 0x00, 0x1f, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // b + 0x00, 0xc0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0x00, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // c + 0x00, 0xc0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0xfe, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // d + 0x00, 0xc0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0xc0, 0x00, 0x00, 0x07, 0x09, 0x11, 0x11, 0x11, 0x11, 0x11, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // e + 0x00, 0x00, 0x10, 0x10, 0xfc, 0x12, 0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // f + 0x00, 0xc0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0xf0, 0x00, 0x00, 0x07, 0x48, 0x90, 0x90, 0x90, 0x90, 0x48, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // g + 0x00, 0xfe, 0x20, 0x10, 0x10, 0x10, 0x10, 0x30, 0xe0, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // h + 0x00, 0x00, 0x10, 0x10, 0xf6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // i + 0x00, 0x00, 0x00, 0x10, 0x10, 0xf6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // j + 0x00, 0xfe, 0x00, 0x80, 0x40, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // k + 0x00, 0x02, 0x02, 0x02, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // l + 0x00, 0xf0, 0x10, 0x10, 0xf0, 0x10, 0x10, 0xe0, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // m + 0x00, 0xf0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x30, 0xe0, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // n + 0x00, 0xc0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0xc0, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // o + 0x00, 0xf0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0xc0, 0x00, 0x00, 0xff, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // p + 0x00, 0xc0, 0x20, 0x10, 0x10, 0x10, 0x10, 0x20, 0xf0, 0x00, 0x00, 0x07, 0x08, 0x10, 0x10, 0x10, 0x10, 0x08, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // q + 0x00, 0x00, 0x00, 0xf0, 0x20, 0x10, 0x10, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // r + 0x00, 0xe0, 0xa0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x20, 0x00, 0x00, 0x08, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0b, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // s + 0x00, 0x10, 0x10, 0xfc, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // t + 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x0f, 0x18, 0x10, 0x10, 0x10, 0x10, 0x08, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // u + 0x00, 0x10, 0xe0, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x00, 0x00, 0x00, 0x00, 0x07, 0x18, 0x18, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // v + 0x30, 0xc0, 0x00, 0x00, 0xc0, 0xc0, 0x00, 0x00, 0xc0, 0x30, 0x00, 0x07, 0x18, 0x07, 0x00, 0x01, 0x06, 0x18, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // w + 0x00, 0x10, 0x30, 0x40, 0x80, 0x80, 0x40, 0x30, 0x10, 0x00, 0x00, 0x10, 0x18, 0x04, 0x03, 0x03, 0x04, 0x18, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // x + 0x00, 0x10, 0xe0, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x00, 0x00, 0x00, 0x80, 0x83, 0xdc, 0x38, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // y + 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x90, 0x50, 0x30, 0x00, 0x00, 0x18, 0x14, 0x12, 0x11, 0x11, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // z + 0x00, 0x00, 0x00, 0x00, 0xfc, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x7e, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // { + 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // | + 0x00, 0x00, 0x02, 0x02, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x7e, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // } + 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ~ +}; + diff --git a/Firmware/Fonts/Font_DejaVu_Sans_Mono_20x34.c b/Firmware/Fonts/Font_DejaVu_Sans_Mono_20x34.c new file mode 100644 index 0000000..c791d07 --- /dev/null +++ b/Firmware/Fonts/Font_DejaVu_Sans_Mono_20x34.c @@ -0,0 +1,109 @@ +#include + +const uint8_t _Font_DejaVu_Sans_Mono_20x34[] = { + 0x00, 0x00, // Size of zero indicates fixed width font, actual length is width * height + 0x14, // Width + 0x22, // Height + 0x20, // First Character + 0x5f, // Character Count + + // Fixed width; char width table not used !!!! + + // Font Data + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ! + 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // " + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0x78, 0x00, 0x00, 0x00, 0xc0, 0xf8, 0xf8, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x0e, 0xee, 0xfe, 0x7f, 0x0f, 0x0e, 0x0e, 0x8e, 0xfe, 0xff, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x0e, 0x0e, 0x0e, 0xce, 0xfe, 0xff, 0x0f, 0x0e, 0x0e, 0x8e, 0xfe, 0xff, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // # + 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xc0, 0xe0, 0xe0, 0xfe, 0xfe, 0xe0, 0xe0, 0xe0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xe1, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0x80, 0x80, 0x81, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x81, 0xff, 0xff, 0x81, 0x81, 0xc3, 0xc7, 0xff, 0xfe, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x7f, 0x7f, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // $ + 0x00, 0xc0, 0xf0, 0x30, 0x18, 0x18, 0x18, 0x18, 0x30, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x0c, 0x18, 0x18, 0x98, 0x98, 0xcc, 0xcf, 0x63, 0x60, 0x20, 0x30, 0x10, 0x18, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x06, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x78, 0xfe, 0x86, 0x03, 0x03, 0x03, 0x03, 0x86, 0xfe, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // % + 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xf0, 0x78, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe3, 0x7f, 0x3f, 0x7c, 0xf8, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x3f, 0x7f, 0xff, 0xf0, 0xc0, 0xc0, 0x80, 0x80, 0x83, 0x87, 0x8f, 0xdf, 0xfc, 0xf8, 0xf8, 0xdf, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x03, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // & + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ' + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xfc, 0x1c, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x1f, 0x7e, 0x70, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ( + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x1c, 0xfc, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x70, 0x7e, 0x1f, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ) + 0x00, 0x00, 0x00, 0x40, 0xe0, 0xc0, 0x80, 0x80, 0x00, 0xf8, 0xf8, 0x00, 0x80, 0x80, 0xc0, 0xe0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x70, 0x30, 0x19, 0x19, 0x0f, 0xff, 0xff, 0x0f, 0x19, 0x19, 0x30, 0x70, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // * + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xff, 0xff, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x3c, 0x1f, 0x0f, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // , + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // - + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // . + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xf8, 0x38, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf8, 0x7f, 0x1f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfe, 0x1f, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x1c, 0x1f, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // / + 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xf0, 0x78, 0x38, 0x38, 0x38, 0x78, 0xf0, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x03, 0x00, 0xc0, 0xe0, 0xe0, 0x40, 0x00, 0x00, 0x03, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x3f, 0xff, 0xf8, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0xc0, 0xe0, 0xf8, 0xff, 0x3f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0 + 0x00, 0x00, 0x00, 0x00, 0x70, 0x70, 0x78, 0x38, 0x38, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1 + 0x00, 0x00, 0x70, 0x70, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0xf0, 0xe0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xb8, 0xbc, 0x9e, 0x8f, 0x87, 0x87, 0x83, 0x81, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2 + 0x00, 0x00, 0x00, 0x70, 0x70, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x78, 0x70, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70, 0x70, 0x70, 0x70, 0xf8, 0xd8, 0xdf, 0x8f, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe1, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0x78, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0x78, 0x1e, 0x0f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x1f, 0x1f, 0x1d, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0xff, 0xff, 0xff, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 4 + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x3f, 0x3f, 0x38, 0x38, 0x38, 0x38, 0x38, 0x78, 0x70, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xc0, 0xe0, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 5 + 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0x78, 0x78, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x87, 0xe0, 0x60, 0x70, 0x70, 0x70, 0x70, 0xf0, 0xe0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x7f, 0xff, 0xe1, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe1, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 6 + 0x00, 0x00, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xb8, 0xf8, 0xf8, 0xf8, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xf0, 0xfc, 0xff, 0x1f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xfe, 0x7f, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 7 + 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0x78, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0xcf, 0xdf, 0xd8, 0x70, 0x70, 0x70, 0x70, 0x70, 0xd8, 0xdf, 0xcf, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xe1, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe1, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8 + 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xf0, 0x78, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xf0, 0xe0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0x30, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x81, 0x81, 0x81, 0x81, 0xc1, 0xc0, 0xe0, 0xfc, 0x7f, 0x3f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 9 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0x3e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // : + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0x3e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x3c, 0x1f, 0x0f, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ; + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xe0, 0xe0, 0x60, 0x70, 0x30, 0x38, 0x38, 0x18, 0x1c, 0x1c, 0x0e, 0x0e, 0x06, 0x07, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x07, 0x07, 0x06, 0x0e, 0x0c, 0x1c, 0x1c, 0x18, 0x38, 0x38, 0x70, 0x70, 0x60, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // < + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // = + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x06, 0x0e, 0x0e, 0x1c, 0x1c, 0x18, 0x38, 0x38, 0x30, 0x70, 0x60, 0xe0, 0xe0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0xe0, 0x60, 0x70, 0x70, 0x38, 0x38, 0x18, 0x1c, 0x1c, 0x0c, 0x0e, 0x06, 0x07, 0x07, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // > + 0x00, 0x00, 0x00, 0x00, 0xe0, 0x70, 0x70, 0x38, 0x38, 0x38, 0x38, 0x38, 0x78, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xf8, 0x3c, 0x1f, 0x0f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ? + 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0x60, 0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x70, 0x60, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0xe0, 0xfc, 0x1f, 0x03, 0x01, 0x00, 0xc0, 0xf0, 0x38, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x39, 0xff, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x0f, 0x3f, 0x70, 0x60, 0xc0, 0xc0, 0xc0, 0xc0, 0x60, 0x70, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x03, 0x0f, 0x0c, 0x18, 0x38, 0x30, 0x70, 0x60, 0x60, 0x60, 0x60, 0x60, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // @ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xf8, 0xf8, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xf8, 0xff, 0x7f, 0x0f, 0x01, 0x01, 0x0f, 0x7f, 0xff, 0xf8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xfc, 0xff, 0x3f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x3f, 0xff, 0xfc, 0xe0, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // A + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0xd8, 0xdf, 0xcf, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe1, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // B + 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0x70, 0x78, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0x70, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1f, 0x7f, 0xf8, 0xe0, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xc0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // C + 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x78, 0x70, 0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xc0, 0xe0, 0xf8, 0x7f, 0x3f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // D + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // E + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // F + 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0x70, 0x78, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0x70, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x3f, 0x7f, 0xf8, 0xe0, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // G + 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // H + 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x38, 0x38, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // I + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // J + 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0x78, 0x38, 0x18, 0x08, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xe0, 0x70, 0x78, 0xfc, 0xfe, 0xc7, 0x83, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x03, 0x07, 0x1f, 0x3e, 0xfc, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // K + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // L + 0x00, 0xf8, 0xf8, 0xf8, 0x78, 0xf8, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf8, 0x78, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x03, 0x1f, 0xfe, 0xf0, 0x80, 0xf0, 0xfe, 0x1f, 0x03, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // M + 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0xf8, 0xf0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x07, 0x1f, 0x7e, 0xf8, 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x3f, 0xfc, 0xe0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // N + 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0x70, 0x78, 0x38, 0x38, 0x38, 0x38, 0x78, 0xf0, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x3f, 0xff, 0xf8, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe0, 0xf8, 0xff, 0x3f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // O + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x78, 0xf0, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xf0, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // P + 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0x70, 0x78, 0x38, 0x38, 0x38, 0x38, 0x78, 0xf0, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x3f, 0xff, 0xf8, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe0, 0xf8, 0xff, 0x3f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x07, 0x0f, 0x1f, 0x3d, 0x18, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Q + 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x78, 0xf0, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0xb8, 0x3f, 0x1f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x0f, 0x3f, 0xfe, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // R + 0x00, 0x00, 0x80, 0xe0, 0xe0, 0xf0, 0x70, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x3f, 0x3f, 0x78, 0x70, 0x70, 0xe0, 0xe0, 0xe0, 0xe0, 0xc0, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc1, 0xe3, 0xff, 0xff, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // S + 0x00, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xf8, 0xf8, 0xf8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // T + 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xe0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // U + 0x00, 0x18, 0xf8, 0xf8, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf8, 0xf8, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x7f, 0xff, 0xf8, 0x80, 0x00, 0x00, 0x00, 0x80, 0xf8, 0xff, 0x7f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x3f, 0xff, 0xfc, 0xc0, 0xfc, 0xff, 0x3f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // V + 0x38, 0xf8, 0xf8, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf8, 0xf8, 0x38, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0xf8, 0xfe, 0x0e, 0xfe, 0xf8, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xf8, 0xff, 0x1f, 0x01, 0x00, 0x01, 0x1f, 0xff, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // W + 0x00, 0x00, 0x08, 0x18, 0x78, 0xf8, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xf8, 0x78, 0x18, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x0f, 0xdf, 0xfe, 0xf8, 0xfe, 0xdf, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xf8, 0x7e, 0x1f, 0x0f, 0x03, 0x01, 0x03, 0x0f, 0x3f, 0x7c, 0xf8, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // X + 0x00, 0x08, 0x38, 0xf8, 0xf8, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf8, 0xf8, 0x38, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x1f, 0x7e, 0xfc, 0xf0, 0xfc, 0x7e, 0x1f, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Y + 0x00, 0x00, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xb8, 0xf8, 0xf8, 0xf8, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf8, 0x7c, 0x3f, 0x0f, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xfc, 0xbe, 0x9f, 0x87, 0x83, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Z + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x7f, 0x7f, 0x70, 0x70, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // [ + 0x00, 0x00, 0x08, 0x38, 0xf8, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1f, 0x7f, 0xf8, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x1f, 0xfe, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x1f, 0x1c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // "\" + 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70, 0x70, 0x70, 0x7f, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ] + 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0x78, 0x38, 0x78, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0c, 0x0e, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0e, 0x0c, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ^ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, // _ + 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0e, 0x3c, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ` + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x0e, 0x0e, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x8f, 0x9e, 0xfe, 0xfc, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfe, 0xff, 0xc7, 0x87, 0x83, 0x83, 0x83, 0x83, 0xc3, 0xc3, 0x63, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // a + 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x3c, 0x0e, 0x06, 0x07, 0x07, 0x07, 0x07, 0x0f, 0x3e, 0xfc, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xf0, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // b + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x3e, 0x1e, 0x0e, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0e, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xf0, 0xe0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // c + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x3e, 0x0f, 0x07, 0x07, 0x07, 0x07, 0x06, 0x0e, 0x3c, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xf0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // d + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x9e, 0x8e, 0x87, 0x87, 0x87, 0x87, 0x87, 0x8f, 0x9e, 0xfc, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xe3, 0xc3, 0xc3, 0x83, 0x83, 0x83, 0x83, 0x83, 0xc3, 0xc3, 0xe3, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // e + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf8, 0xf8, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0xff, 0xff, 0xff, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // f + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x3e, 0x0f, 0x07, 0x07, 0x07, 0x07, 0x06, 0x0e, 0x3c, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xf0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe1, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc1, 0xe1, 0xf0, 0x7f, 0x3f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // g + 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x18, 0x0e, 0x06, 0x07, 0x07, 0x07, 0x1f, 0xfe, 0xfc, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // h + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // i + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xff, 0x7f, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // j + 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0x3c, 0x1e, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x07, 0x03, 0x03, 0x07, 0x1f, 0x3e, 0x7c, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // k + 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // l + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0x07, 0x07, 0x0f, 0xff, 0xfe, 0xf8, 0x0e, 0x07, 0x07, 0x0f, 0xff, 0xfe, 0xf8, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // m + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x18, 0x0e, 0x06, 0x07, 0x07, 0x07, 0x1f, 0xfe, 0xfc, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // n + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x3e, 0x0f, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0f, 0x3e, 0xfc, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xf0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xf0, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // o + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x3c, 0x0e, 0x06, 0x07, 0x07, 0x07, 0x07, 0x0f, 0x3e, 0xfc, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xf0, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // p + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x3e, 0x0f, 0x07, 0x07, 0x07, 0x07, 0x06, 0x0e, 0x3c, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0xff, 0xf0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, // q + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x38, 0x0e, 0x0e, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // r + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xfe, 0xfe, 0xcf, 0xc7, 0xc7, 0x87, 0x87, 0x87, 0x87, 0x0f, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xc0, 0xc1, 0x81, 0x81, 0x81, 0x83, 0x83, 0xc3, 0xc7, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // s + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0xff, 0xff, 0xff, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // t + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xe0, 0x80, 0x80, 0x80, 0x80, 0xc0, 0x60, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // u + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x7f, 0xfe, 0xf0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0xf0, 0xfe, 0x7f, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1f, 0xff, 0xfc, 0xe0, 0xe0, 0xfc, 0xff, 0x1f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // v + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x7f, 0xff, 0xfc, 0xc0, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0xc0, 0xfc, 0xff, 0x7f, 0x03, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xf8, 0xf0, 0x7f, 0x0f, 0x00, 0x0f, 0x7f, 0xf0, 0xf8, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // w + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x0f, 0x1f, 0x3e, 0xf8, 0xf0, 0xc0, 0xf0, 0xf8, 0x3e, 0x1f, 0x0f, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xf8, 0x3e, 0x1f, 0x0f, 0x1f, 0x3e, 0xf8, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // x + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x7f, 0xfe, 0xf8, 0xc0, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf8, 0xfe, 0x7f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x7f, 0xfe, 0xf0, 0xf8, 0xfe, 0x7f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xe0, 0xf0, 0xff, 0x7f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // y + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xc7, 0xe7, 0xff, 0x7f, 0x3f, 0x1f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xfc, 0xbe, 0x9f, 0x8f, 0x83, 0x81, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // z + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xf8, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x07, 0xfe, 0xfe, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7f, 0x7f, 0xf0, 0xe0, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // | + 0x00, 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xfe, 0xfe, 0x07, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0x7f, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // } + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xc0, 0xe0, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ~ +}; + diff --git a/Firmware/Fonts/Font_DejaVu_Sans_Mono_6x12.c b/Firmware/Fonts/Font_DejaVu_Sans_Mono_6x12.c new file mode 100644 index 0000000..a45c7a5 --- /dev/null +++ b/Firmware/Fonts/Font_DejaVu_Sans_Mono_6x12.c @@ -0,0 +1,109 @@ +#include + +const uint8_t _Font_DejaVu_Sans_Mono_6x12[] = { + 0x00, 0x00, // Size of zero indicates fixed width font, actual length is width * height + 0x06, // Width + 0x0c, // Height + 0x20, // First Char + 0x5f, // Char Count + + // Fixed width; char width table not used !!!! + + // Font Data + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, // ! + 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // " + 0x80, 0xe0, 0xb8, 0xe0, 0xb8, 0x20, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, // # + 0x00, 0x60, 0x50, 0xf8, 0x90, 0x90, 0x00, 0x02, 0x02, 0x07, 0x02, 0x01, // $ + 0x38, 0xa8, 0x78, 0xc0, 0xa0, 0x80, 0x00, 0x00, 0x00, 0x03, 0x02, 0x03, // % + 0x00, 0xc0, 0x38, 0x68, 0x88, 0xc0, 0x00, 0x01, 0x02, 0x02, 0x01, 0x02, // & + 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ' + 0x00, 0x00, 0xf8, 0x04, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, // ( + 0x00, 0x00, 0x0c, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x06, 0x01, 0x00, 0x00, // ) + 0x00, 0x48, 0x30, 0x78, 0x30, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // * + 0x00, 0x40, 0x40, 0xf0, 0x40, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, // + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, // , + 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // - + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // . + 0x00, 0x00, 0x00, 0xc0, 0x30, 0x08, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00, // / + 0x00, 0xf0, 0x08, 0x48, 0x08, 0xf0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // 0 + 0x00, 0x08, 0x08, 0xf8, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 0x02, 0x02, // 1 + 0x00, 0x10, 0x08, 0x88, 0xc8, 0x70, 0x00, 0x02, 0x03, 0x02, 0x02, 0x02, // 2 + 0x00, 0x10, 0x48, 0x48, 0x48, 0xb0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // 3 + 0x00, 0xc0, 0xe0, 0x90, 0xf8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, // 4 + 0x00, 0x38, 0x28, 0x28, 0x28, 0xc0, 0x00, 0x02, 0x02, 0x02, 0x02, 0x01, // 5 + 0x00, 0xf0, 0x58, 0x48, 0x48, 0x88, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // 6 + 0x00, 0x08, 0x08, 0x88, 0x78, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, // 7 + 0x00, 0xb0, 0x48, 0x48, 0x48, 0xb0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // 8 + 0x00, 0x30, 0x48, 0x48, 0x48, 0xf0, 0x00, 0x02, 0x02, 0x02, 0x03, 0x01, // 9 + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // : + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, // ; + 0x00, 0x40, 0xa0, 0xa0, 0xa0, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, // < + 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // = + 0x00, 0x10, 0xa0, 0xa0, 0xa0, 0x40, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, // > + 0x00, 0x08, 0xc8, 0x28, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // ? + 0x00, 0xe0, 0x18, 0xe8, 0x28, 0xf0, 0x00, 0x03, 0x04, 0x0b, 0x0a, 0x03, // @ + 0x00, 0x00, 0xe0, 0x98, 0xe0, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, // A + 0x00, 0xf8, 0x48, 0x48, 0x48, 0xb0, 0x00, 0x03, 0x02, 0x02, 0x02, 0x01, // B + 0x00, 0xf0, 0x18, 0x08, 0x08, 0x18, 0x00, 0x01, 0x03, 0x02, 0x02, 0x03, // C + 0x00, 0xf8, 0x08, 0x08, 0x18, 0xf0, 0x00, 0x03, 0x02, 0x02, 0x03, 0x01, // D + 0x00, 0xf8, 0x48, 0x48, 0x48, 0x48, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, // E + 0x00, 0xf8, 0x48, 0x48, 0x48, 0x48, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, // F + 0x00, 0xf0, 0x18, 0x08, 0x48, 0xd0, 0x00, 0x01, 0x03, 0x02, 0x02, 0x03, // G + 0x00, 0xf8, 0x40, 0x40, 0x40, 0xf8, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, // H + 0x00, 0x08, 0x08, 0xf8, 0x08, 0x08, 0x00, 0x02, 0x02, 0x03, 0x02, 0x02, // I + 0x00, 0x00, 0x08, 0x08, 0xf8, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, // J + 0x00, 0xf8, 0x40, 0xa0, 0x10, 0x08, 0x00, 0x03, 0x00, 0x00, 0x01, 0x02, // K + 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, // L + 0x00, 0xf8, 0x30, 0x40, 0x30, 0xf8, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, // M + 0x00, 0xf8, 0x30, 0x40, 0x80, 0xf8, 0x00, 0x03, 0x00, 0x00, 0x01, 0x03, // N + 0x00, 0xf0, 0x08, 0x08, 0x08, 0xf0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // O + 0x00, 0xf8, 0x48, 0x48, 0x48, 0x30, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, // P + 0x00, 0xf0, 0x08, 0x08, 0x08, 0xf0, 0x00, 0x01, 0x02, 0x02, 0x06, 0x05, // Q + 0x00, 0xf8, 0x48, 0x48, 0xc8, 0xb0, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, // R + 0x00, 0x30, 0x48, 0x48, 0x48, 0x90, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // S + 0x00, 0x08, 0x08, 0xf8, 0x08, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // T + 0x00, 0xf8, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // U + 0x00, 0x18, 0xe0, 0x00, 0xe0, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // V + 0x38, 0xc0, 0x70, 0x70, 0xc0, 0x38, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, // W + 0x00, 0x08, 0xb0, 0x40, 0xb0, 0x08, 0x00, 0x02, 0x01, 0x00, 0x01, 0x02, // X + 0x00, 0x08, 0x30, 0xc0, 0x30, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // Y + 0x00, 0x08, 0x88, 0x48, 0x38, 0x08, 0x00, 0x02, 0x03, 0x02, 0x02, 0x02, // Z + 0x00, 0x00, 0xfc, 0x04, 0x00, 0x00, 0x00, 0x00, 0x07, 0x04, 0x00, 0x00, // [ + 0x00, 0x08, 0x30, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, // "\" + 0x00, 0x00, 0x04, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00, // ] + 0x20, 0x10, 0x08, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ^ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, // _ + 0x00, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ` + 0x00, 0x20, 0xa0, 0xa0, 0xa0, 0xc0, 0x00, 0x03, 0x02, 0x02, 0x02, 0x03, // a + 0x00, 0xfc, 0x20, 0x20, 0x20, 0xc0, 0x00, 0x03, 0x02, 0x02, 0x02, 0x01, // b + 0x00, 0xc0, 0x20, 0x20, 0x20, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x00, // c + 0x00, 0xc0, 0x20, 0x20, 0x20, 0xfc, 0x00, 0x01, 0x02, 0x02, 0x02, 0x03, // d + 0x00, 0xc0, 0xa0, 0xa0, 0xa0, 0xc0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, // e + 0x00, 0x20, 0xf8, 0x24, 0x24, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, // f + 0x00, 0xc0, 0x20, 0x20, 0x20, 0xe0, 0x00, 0x01, 0x0a, 0x0a, 0x0a, 0x07, // g + 0x00, 0xfc, 0x40, 0x20, 0x20, 0xc0, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, // h + 0x00, 0x00, 0x20, 0xe4, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 0x02, 0x02, // i + 0x00, 0x20, 0x20, 0xe4, 0x00, 0x00, 0x00, 0x08, 0x08, 0x07, 0x00, 0x00, // j + 0x00, 0xfc, 0x80, 0xc0, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x02, // k + 0x04, 0x04, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x00, // l + 0x00, 0xe0, 0x20, 0xe0, 0x20, 0xe0, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, // m + 0x00, 0xe0, 0x40, 0x20, 0x20, 0xc0, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, // n + 0x00, 0xc0, 0x20, 0x20, 0x20, 0xc0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, // o + 0x00, 0xe0, 0x20, 0x20, 0x20, 0xc0, 0x00, 0x0f, 0x02, 0x02, 0x02, 0x01, // p + 0x00, 0xc0, 0x20, 0x20, 0x20, 0xe0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x0f, // q + 0x00, 0x00, 0xe0, 0x20, 0x20, 0x60, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, // r + 0x00, 0x40, 0xa0, 0xa0, 0xa0, 0xa0, 0x00, 0x02, 0x02, 0x02, 0x02, 0x01, // s + 0x00, 0x20, 0xf8, 0x20, 0x20, 0x00, 0x00, 0x00, 0x03, 0x02, 0x02, 0x00, // t + 0x00, 0xe0, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x01, 0x02, 0x02, 0x02, 0x03, // u + 0x00, 0x20, 0xc0, 0x00, 0xc0, 0x20, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, // v + 0x00, 0x60, 0x80, 0x40, 0x80, 0x60, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, // w + 0x00, 0x20, 0x60, 0x80, 0x60, 0x20, 0x00, 0x02, 0x03, 0x00, 0x03, 0x02, // x + 0x00, 0x20, 0xc0, 0x00, 0xc0, 0x20, 0x00, 0x08, 0x08, 0x07, 0x00, 0x00, // y + 0x00, 0x20, 0x20, 0xa0, 0x60, 0x20, 0x00, 0x02, 0x03, 0x02, 0x02, 0x02, // z + 0x00, 0x40, 0x40, 0xbc, 0x04, 0x00, 0x00, 0x00, 0x00, 0x07, 0x04, 0x00, // { + 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, // | + 0x00, 0x00, 0x04, 0xbc, 0x40, 0x40, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00, // } + 0x00, 0x40, 0x40, 0x40, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ~ +}; + diff --git a/Firmware/Fonts/Font_DejaVu_Sans_Mono_Bold_15x26.c b/Firmware/Fonts/Font_DejaVu_Sans_Mono_Bold_15x26.c new file mode 100644 index 0000000..9318802 --- /dev/null +++ b/Firmware/Fonts/Font_DejaVu_Sans_Mono_Bold_15x26.c @@ -0,0 +1,109 @@ +#include + +const uint8_t _Font_DejaVu_Sans_Mono_Bold_15x26[] = { + 0x00, 0x00, // Size of zero indicates fixed width font, actual length is width * height + 0x0f, // Width + 0x1a, // Height + 0x20, // First Character + 0x5f, // Character Count + + // Fixed width; char width table not used !!!! + + // Font Data + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ! + 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // " + 0x00, 0x80, 0x80, 0x80, 0x80, 0xf8, 0xf8, 0x98, 0x80, 0xc0, 0xf8, 0xf8, 0x98, 0x80, 0x00, 0xe0, 0xe3, 0xe3, 0xfb, 0xff, 0xff, 0xe3, 0xe3, 0xfb, 0xff, 0xef, 0xe3, 0xe3, 0x03, 0x00, 0x00, 0x08, 0x0f, 0x0f, 0x01, 0x00, 0x08, 0x0f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // # + 0x00, 0x80, 0xc0, 0xc0, 0xe0, 0xe0, 0xfc, 0xfc, 0xe0, 0xe0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1f, 0x1f, 0x3c, 0x38, 0xff, 0xff, 0x38, 0x70, 0xf0, 0xe1, 0xc0, 0x00, 0x00, 0x00, 0x07, 0x07, 0x0e, 0x0e, 0x0e, 0xff, 0xff, 0x0e, 0x0f, 0x07, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // $ + 0x70, 0xf8, 0x8c, 0x8c, 0x8c, 0xf8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x60, 0x21, 0x31, 0x11, 0x08, 0x08, 0x84, 0xc6, 0x62, 0x63, 0x61, 0xc1, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0c, 0x0c, 0x0c, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // % + 0x00, 0x00, 0x00, 0xf0, 0xf8, 0xfc, 0x9c, 0x1c, 0x1c, 0x1c, 0x1c, 0x38, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf8, 0xfc, 0x0f, 0x07, 0x1f, 0x3e, 0x7c, 0xf8, 0xe0, 0xc0, 0xf8, 0xf8, 0x78, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x0f, 0x0f, 0x0e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // & + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ' + 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x1c, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x3f, 0x7e, 0x70, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ( + 0x00, 0x00, 0x00, 0x00, 0x04, 0x1c, 0xfc, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x70, 0x7e, 0x3f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ) + 0x00, 0x20, 0x70, 0x60, 0xe0, 0xc0, 0xfc, 0xfc, 0xc0, 0xe0, 0x60, 0x70, 0x20, 0x00, 0x00, 0x00, 0x04, 0x0e, 0x06, 0x07, 0x03, 0x3f, 0x3f, 0x03, 0x07, 0x06, 0x0e, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // * + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x38, 0x38, 0xff, 0xff, 0xff, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // , + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // - + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // . + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0x1c, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xfc, 0x3f, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x38, 0x3f, 0x1f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // / + 0x00, 0xc0, 0xf0, 0xf8, 0x7c, 0x1c, 0x1c, 0x1c, 0x1c, 0x7c, 0xf8, 0xf0, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0x00, 0x0e, 0x0e, 0x0e, 0x80, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0 + 0x00, 0x00, 0x38, 0x38, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1 + 0x00, 0x38, 0x38, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0x78, 0x3c, 0x1e, 0x0f, 0x03, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2 + 0x00, 0x00, 0x38, 0x18, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf8, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x1f, 0xfb, 0xfb, 0xf1, 0x00, 0x00, 0x00, 0x07, 0x07, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3 + 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0x3c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xfc, 0xff, 0xe7, 0xe3, 0xe0, 0xe0, 0xff, 0xff, 0xff, 0xe0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 4 + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0f, 0x0f, 0xfe, 0xfc, 0xf8, 0x00, 0x00, 0x00, 0x07, 0x06, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 5 + 0x00, 0x80, 0xe0, 0xf0, 0x78, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x38, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0x07, 0x07, 0x07, 0x07, 0x0f, 0xfe, 0xfe, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 6 + 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x9c, 0xfc, 0xfc, 0xfc, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xfc, 0x7f, 0x1f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0e, 0x0f, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 7 + 0x00, 0xe0, 0xf8, 0xf8, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0xf1, 0xfb, 0xfb, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e, 0x1f, 0xfb, 0xfb, 0xe1, 0x00, 0x00, 0x00, 0x01, 0x07, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8 + 0x00, 0xe0, 0xf0, 0xf8, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x07, 0x1f, 0x1f, 0x3c, 0x38, 0x38, 0x38, 0x38, 0x9c, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 9 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // : + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ; + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0xc0, 0x00, 0x00, 0x00, 0x38, 0x7c, 0x7c, 0x6c, 0xee, 0xee, 0xc7, 0xc7, 0x83, 0x83, 0x83, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // < + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // = + 0x00, 0xc0, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x83, 0x83, 0x83, 0xc7, 0xc7, 0xee, 0xee, 0x6c, 0x7c, 0x7c, 0x38, 0x00, 0x00, 0x00, 0x07, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // > + 0x00, 0x00, 0x00, 0x38, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0xfc, 0xf8, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf8, 0xfc, 0x0e, 0x07, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ? + 0x00, 0x00, 0xc0, 0xc0, 0x60, 0x70, 0x30, 0x30, 0x30, 0x30, 0x70, 0xe0, 0xc0, 0x80, 0x00, 0xfc, 0xff, 0x07, 0x01, 0xf0, 0xfc, 0x0c, 0x06, 0x06, 0x06, 0x06, 0x0c, 0xff, 0xff, 0x00, 0x03, 0x0f, 0x1e, 0x38, 0x70, 0x63, 0xc3, 0xc6, 0xc6, 0xc6, 0xc6, 0xc3, 0x67, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // @ + 0x00, 0x00, 0x00, 0x80, 0xf8, 0xfc, 0x7c, 0x7c, 0xfc, 0xf8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf8, 0xff, 0xff, 0xef, 0xe0, 0xe0, 0xef, 0xff, 0xff, 0xf8, 0xc0, 0x00, 0x00, 0x0c, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // A + 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf8, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x1b, 0xfb, 0xf9, 0xe0, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // B + 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xf8, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0x78, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // C + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x38, 0xf8, 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // D + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // E + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // F + 0x00, 0x80, 0xe0, 0xf0, 0xf8, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // G + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // H + 0x00, 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // I + 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // J + 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x80, 0xc0, 0xe0, 0xf8, 0x7c, 0x3c, 0x0c, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x0f, 0x3f, 0xff, 0xfc, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x0f, 0x0f, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // K + 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // L + 0x00, 0xfc, 0xfc, 0xfc, 0xfc, 0xf0, 0x00, 0x00, 0xf0, 0xfc, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x1f, 0x3f, 0x3f, 0x1f, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // M + 0x00, 0xfc, 0xfc, 0xfc, 0xfc, 0xe0, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x07, 0x3f, 0xf8, 0xc0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // N + 0x00, 0x80, 0xf0, 0xf8, 0x78, 0x1c, 0x1c, 0x1c, 0x1c, 0x78, 0xf8, 0xf0, 0x80, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x07, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // O + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1c, 0x1c, 0x1c, 0x1c, 0x1e, 0x0f, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // P + 0x00, 0x80, 0xf0, 0xf8, 0x78, 0x1c, 0x1c, 0x1c, 0x1c, 0x78, 0xf8, 0xf0, 0x80, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x07, 0x0e, 0x0e, 0x0e, 0x1e, 0x3f, 0x7f, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Q + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0xf8, 0xf8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1c, 0x1c, 0x1c, 0x7c, 0xfe, 0xf7, 0xe7, 0x83, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0f, 0x0f, 0x0e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // R + 0x00, 0x00, 0xe0, 0xf8, 0xf8, 0x3c, 0x1c, 0x1c, 0x1c, 0x1c, 0x3c, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x07, 0x07, 0x0f, 0x0e, 0x1e, 0x1e, 0x3c, 0xfc, 0xf8, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // S + 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // T + 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // U + 0x00, 0x0c, 0xfc, 0xfc, 0xfc, 0x80, 0x00, 0x00, 0x00, 0x80, 0xfc, 0xfc, 0xfc, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x1f, 0xff, 0xff, 0xf0, 0x00, 0xf0, 0xff, 0xff, 0x1f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x0f, 0x0e, 0x0f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // V + 0x3c, 0xfc, 0xfc, 0x80, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0xfc, 0xfc, 0x7c, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xe0, 0xff, 0x1f, 0x1f, 0xff, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x03, 0x00, 0x00, 0x03, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // W + 0x04, 0x1c, 0x3c, 0xfc, 0xf0, 0xe0, 0x80, 0x80, 0xe0, 0xf0, 0xfc, 0x3c, 0x1c, 0x04, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf3, 0xff, 0x7f, 0x7f, 0xff, 0xf3, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0e, 0x0f, 0x0f, 0x03, 0x01, 0x00, 0x00, 0x01, 0x03, 0x0f, 0x0f, 0x0e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // X + 0x00, 0x04, 0x1c, 0x7c, 0xfc, 0xf0, 0xc0, 0x00, 0xc0, 0xf0, 0xfc, 0x7c, 0x1c, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0xff, 0xfe, 0xff, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Y + 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x9c, 0xdc, 0xfc, 0xfc, 0x7c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0xfc, 0x7e, 0x1f, 0x0f, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Z + 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x7f, 0x7f, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // [ + 0x00, 0x04, 0x1c, 0x7c, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x3f, 0xfc, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x3e, 0x38, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // "\" + 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x0c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x60, 0x7f, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ] + 0x00, 0x00, 0x80, 0xc0, 0xf0, 0x78, 0x3c, 0x1c, 0x3c, 0x78, 0xf0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ^ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, // _ + 0x00, 0x00, 0x00, 0x02, 0x06, 0x0e, 0x1c, 0x18, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ` + 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe7, 0xf7, 0x73, 0x73, 0x73, 0x73, 0x73, 0x77, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x06, 0x07, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // a + 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x06, 0x03, 0x03, 0x03, 0x03, 0x07, 0xff, 0xfe, 0xfc, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x03, 0x06, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // b + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xfe, 0xff, 0x8f, 0x07, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // c + 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0xfe, 0xff, 0x07, 0x03, 0x03, 0x03, 0x03, 0x06, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x06, 0x03, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // d + 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xfe, 0xff, 0x77, 0x73, 0x73, 0x73, 0x73, 0x77, 0x7f, 0x7e, 0x7c, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // e + 0x00, 0x00, 0x80, 0x80, 0x80, 0xf8, 0xfc, 0xfc, 0x9c, 0x9c, 0x9c, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0xff, 0xff, 0xff, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // f + 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0xfc, 0xfe, 0xff, 0x07, 0x03, 0x03, 0x03, 0x03, 0x07, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0xe3, 0xc7, 0xcf, 0xce, 0xce, 0xce, 0xce, 0xe7, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // g + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x07, 0x03, 0x03, 0x03, 0x07, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // h + 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x8f, 0x8f, 0x8f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // i + 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x8f, 0x8f, 0x8f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // j + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x78, 0x3c, 0xfe, 0xff, 0xe7, 0x83, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0f, 0x0f, 0x0c, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // k + 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // l + 0x00, 0x80, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x03, 0x03, 0xff, 0xff, 0xfe, 0x03, 0x03, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // m + 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x07, 0x03, 0x03, 0x03, 0x07, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // n + 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfe, 0xff, 0x07, 0x03, 0x03, 0x03, 0x03, 0x07, 0xff, 0xfe, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // o + 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x06, 0x03, 0x03, 0x03, 0x03, 0x07, 0xff, 0xfe, 0xfc, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x03, 0x06, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // p + 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0xfc, 0xfe, 0xff, 0x07, 0x03, 0x03, 0x03, 0x03, 0x06, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x06, 0x03, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, // q + 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0x07, 0x03, 0x03, 0x03, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // r + 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x3f, 0x3f, 0x3b, 0x7b, 0x73, 0x73, 0x73, 0xf3, 0xe7, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // s + 0x00, 0x00, 0x80, 0x80, 0x80, 0xf8, 0xf8, 0xf8, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0xff, 0xff, 0xff, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // t + 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0f, 0x0e, 0x0e, 0x06, 0x07, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // u + 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x7f, 0xff, 0xf8, 0x80, 0x80, 0xf8, 0xff, 0x7f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x0f, 0x0f, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // v + 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x03, 0x7f, 0xff, 0xf8, 0x00, 0xf8, 0x7c, 0x7c, 0xf8, 0x00, 0xf8, 0xff, 0x7f, 0x03, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // w + 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0xcf, 0xff, 0xfc, 0xfc, 0xff, 0xcf, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0c, 0x0f, 0x0f, 0x07, 0x01, 0x01, 0x07, 0x0f, 0x0f, 0x0c, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // x + 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x07, 0x3f, 0xff, 0xfc, 0xe0, 0xc0, 0xfc, 0xff, 0x3f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xe0, 0xff, 0xff, 0x7f, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // y + 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x83, 0xe3, 0xf3, 0xfb, 0x7f, 0x3f, 0x0f, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // z + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xfc, 0xfc, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x78, 0xff, 0xff, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // | + 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x0c, 0xfc, 0xfc, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xff, 0x78, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // } + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ~ +}; + diff --git a/Firmware/I2C_Master.c b/Firmware/I2C_Master.c new file mode 100644 index 0000000..c414a4d --- /dev/null +++ b/Firmware/I2C_Master.c @@ -0,0 +1,160 @@ +/* + * I2C_Master.c + * + * Created: Sun Sep 11 2022 12:00:14 + * Author Chris + */ + +// ============================================================================================ +// Includes +#include "I2C_Master.h" + +#include "pico/malloc.h" +#include "hardware/i2c.h" +#include "hardware/dma.h" +#include "hardware/irq.h" + + +// ============================================================================================ +// Defines +#define I2C_HARDWARE_UNIT (&i2c1_inst) +#define I2C_BAUDRATE_HZ 400000UL + +#define I2C_SCL_PIN 7 +#define I2C_SDA_PIN 6 + + +// ============================================================================================ +// Variables +static bool _DMA_Transfer_Complete; +static int _DMA_Transmit_Claim; +static dma_channel_config _DMA_Transmit_Channel; + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Interrupt Service Routines +*******************************************************************/ +void ISR_I2C_DMA_Transmit_Complete() +{ + dma_hw->ints0 = (1u << _DMA_Transmit_Claim); + + _DMA_Transfer_Complete = true; +} + + +/******************************************************************* + Functions +*******************************************************************/ +void I2CM_Init(bool use_internal_pullups) +{ + i2c_init(I2C_HARDWARE_UNIT, I2C_BAUDRATE_HZ); + gpio_set_function(I2C_SDA_PIN, GPIO_FUNC_I2C); + gpio_set_function(I2C_SCL_PIN, GPIO_FUNC_I2C); + + /* Function for internal pull-ups has not been tested yet */ + if(use_internal_pullups == true) + { + gpio_pull_up(I2C_SDA_PIN); + gpio_pull_up(I2C_SCL_PIN); + } + + + // Configura DMA Channel for SPI Transmit function + _DMA_Transmit_Claim = dma_claim_unused_channel(false); + _DMA_Transmit_Channel = dma_channel_get_default_config(_DMA_Transmit_Claim); + + // channel_config_set_transfer_data_size(&_DMA_Transmit_Channel, DMA_SIZE_8); + channel_config_set_transfer_data_size(&_DMA_Transmit_Channel, DMA_SIZE_16); + channel_config_set_dreq(&_DMA_Transmit_Channel, i2c_get_dreq(I2C_HARDWARE_UNIT, true)); + channel_config_set_read_increment(&_DMA_Transmit_Channel, true); + channel_config_set_write_increment(&_DMA_Transmit_Channel, false); + dma_channel_configure( _DMA_Transmit_Claim, + &_DMA_Transmit_Channel, + &i2c_get_hw(I2C_HARDWARE_UNIT)->data_cmd, // Write Address + NULL, // Read Address + 0, // Element Count (Each element is of size transfer_data_size) + false); // DO NOT start directly + + + dma_channel_set_irq1_enabled(_DMA_Transmit_Claim, true); + + // Configure the processor to run the ISR when DMA IRQ 0 is asserted + irq_set_exclusive_handler(DMA_IRQ_1, ISR_I2C_DMA_Transmit_Complete); + irq_set_enabled(DMA_IRQ_1, true); + + _DMA_Transfer_Complete = true; +} + +int I2CM_Transmit(uint8_t slave_address, void *data, size_t data_length, bool use_dma, bool nostop) +{ + if(use_dma) + { + // return 0; + if(dma_channel_is_busy(_DMA_Transmit_Claim)) { + return 0; + } + + // Apply flag for Stop Bit at last Data Set + ((uint16_t*)data)[data_length-1] |= I2C_IC_DATA_CMD_STOP_BITS; + + dma_channel_set_read_addr (_DMA_Transmit_Claim, (uint16_t*) data , false); + dma_channel_set_trans_count (_DMA_Transmit_Claim, data_length , true); + } + else + { + return i2c_write_blocking(I2C_HARDWARE_UNIT, slave_address, (uint8_t*)data, data_length, nostop); + } +} + +int I2CM_Receive(uint8_t slave_address, uint8_t *receive_data, size_t data_length) +{ + return i2c_read_blocking(I2C_HARDWARE_UNIT, slave_address, receive_data, data_length, false); +} + +bool I2CM_DMA_Transmit_Complete() +{ + bool Return_Value = _DMA_Transfer_Complete; + + _DMA_Transfer_Complete = false; + + return Return_Value; +} + +int I2CM_Packet_Transmit(uint8_t slave_address, uint reg_address, uint8_t address_length, uint8_t *transmit_data, uint8_t data_length) +{ + uint8_t *Transmit_Data = malloc(address_length + data_length); + + for(uint i=0;i> (8*(address_length - i - 1))); + } + + for(uint i=0;i> (8*(address_length - i - 1))); + } + + int status = I2CM_Transmit(slave_address, Address_Data, address_length, false, true); + + return I2CM_Receive(slave_address, receive_data, data_length); +} \ No newline at end of file diff --git a/Firmware/I2C_Master.h b/Firmware/I2C_Master.h new file mode 100644 index 0000000..0539b4f --- /dev/null +++ b/Firmware/I2C_Master.h @@ -0,0 +1,39 @@ +/* + * I2C_Master.h + * + * Created: 22/01/2020 18:36:25 + * Author: Chris + */ +#ifndef I2C_MASTER_H_ +#define I2C_MASTER_H_ + +// ============================================================================================ +// Includes +#include +#include +#include + +#include "pico/types.h" +#include "pico/stdlib.h" + + +// ============================================================================================ +// Defines +#define I2C_USE_INTERNAL_PULLUP true +#define I2C_NO_INTERNAL_PULLUP false + + +// ============================================================================================ +// Function Declarations +void I2CM_Init(bool use_internal_pullups); + +int I2CM_Transmit(uint8_t slave_address, void *data, size_t data_length, bool use_dma, bool nostop); +int I2CM_Receive(uint8_t slave_address, uint8_t *receive_data, size_t data_length); +bool I2CM_DMA_Transmit_Complete(); + +int I2CM_Packet_Transmit(const uint8_t slave_address, const uint reg_address, const uint8_t address_length, uint8_t *transmit_data, const uint8_t data_length); +int I2CM_Packet_Receive (const uint8_t slave_address, const uint reg_address, const uint8_t address_length, uint8_t *receive_data , const uint8_t data_length); + +void I2CM_Set_Address(const uint8_t Address); + +#endif // I2C_MASTER_H_ \ No newline at end of file diff --git a/Firmware/INA260.c b/Firmware/INA260.c new file mode 100644 index 0000000..c5d3893 --- /dev/null +++ b/Firmware/INA260.c @@ -0,0 +1,98 @@ +/* + * File: INA260.c + * + * Created: Created: Sunday August 2025 21:52:23 + * Author: Chris + */ +#include "INA260.h" + + +// ============================================================================================ +// Includes + + +// ============================================================================================ +// Defines +#define INA260_I2CADDR_DEFAULT 0x40 ///< INA260 default i2c address +#define INA260_REG_CONFIG 0x00 ///< Configuration register +#define INA260_REG_CURRENT 0x01 ///< Current measurement register (signed) in mA +#define INA260_REG_BUSVOLTAGE 0x02 ///< Bus voltage measurement register in mV +#define INA260_REG_POWER 0x03 ///< Power calculation register in mW +#define INA260_REG_MASK_ENABLE 0x06 ///< Interrupt/Alert setting and checking register +#define INA260_REG_ALERT_LIMIT 0x00 ///< Alert limit value register +#define INA260_REG_MFG_UID 0xFE ///< Manufacturer ID Register +#define INA260_REG_DIE_UID 0xFF ///< Die ID and Revision Register + + +// ============================================================================================ +// Typedefs +typedef enum _INA260_Mode { + INA260_MODE_SHUTDOWN = 0x00, ///< SHUTDOWN: Minimize quiescient current and turn off current into the device inputs. Set another mode to exit shutown mode + INA260_MODE_TRIGGERED = 0x03, ///< TRIGGERED: Trigger a one-shot measurement of current and bus voltage. Set the TRIGGERED mode again to take a new measurement + INA260_MODE_CONTINUOUS = 0x07, ///< CONTINUOUS: (Default) Continuously update the current, bus voltage and power registers with new measurements +} INA260_MeasurementMode; + +typedef enum _INA260_ConversionTime { + INA260_TIME_140_us, ///< Measurement time: 140us + INA260_TIME_204_us, ///< Measurement time: 204us + INA260_TIME_332_us, ///< Measurement time: 332us + INA260_TIME_588_us, ///< Measurement time: 588us + INA260_TIME_1_1_ms, ///< Measurement time: 1.1ms (Default) + INA260_TIME_2_116_ms, ///< Measurement time: 2.116ms + INA260_TIME_4_156_ms, ///< Measurement time: 4.156ms + INA260_TIME_8_244_ms, ///< Measurement time: 8.224ms +} INA260_ConversionTime; + +typedef enum _count { + INA260_COUNT_1, ///< Window size: 1 sample (Default) + INA260_COUNT_4, ///< Window size: 4 samples + INA260_COUNT_16, ///< Window size: 16 samples + INA260_COUNT_64, ///< Window size: 64 samples + INA260_COUNT_128, ///< Window size: 128 samples + INA260_COUNT_256, ///< Window size: 256 samples + INA260_COUNT_512, ///< Window size: 512 samples + INA260_COUNT_1024, ///< Window size: 1024 samples +} INA260_AveragingCount; + +typedef enum _INA260_AlertType { + INA260_ALERT_CONVERSION_READY = 0x01, ///< Trigger on conversion ready + INA260_ALERT_OVERPOWER = 0x02, ///< Trigger on power over limit + INA260_ALERT_UNDERVOLTAGE = 0x04, ///< Trigger on bus voltage under limit + INA260_ALERT_OVERVOLTAGE = 0x08 , ///< Trigger on bus voltage over limit + INA260_ALERT_UNDERCURRENT = 0x10, ///< Trigger on current under limit + INA260_ALERT_OVERCURRENT = 0x20, ///< Trigger on current over limit + INA260_ALERT_NONE = 0x00 ///< Do not trigger alert pin (Default) +} INA260_AlertType; + +typedef enum _INA260_AlertPolarity { + INA260_ALERT_POLARITY_NORMAL = 0x0, ///< Active high open-collector (Default) + INA260_ALERT_POLARITY_INVERTED = 0x1 ///< Active low open-collector +} INA260_AlertPolarity; + +typedef enum _INA260_AlertLatch { + INA260_ALERT_LATCH_ENABLED = 0x1, ///< Alert will latch until Mask/Enable register is read + INA260_ALERT_LATCH_TRANSPARENT = 0x0 ///< Alert will reset when fault is cleared +} INA260_AlertLatch; + + +// ============================================================================================ +// Variables + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ +void INA260_Init() +{ + +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ + diff --git a/Firmware/INA260.h b/Firmware/INA260.h new file mode 100644 index 0000000..4c1a24b --- /dev/null +++ b/Firmware/INA260.h @@ -0,0 +1,25 @@ +/* + * File: INA260.h + * Created: Created: Sunday August 2025 21:52:19 + * Author: Chris + */ +#ifndef INA260_H +#define INA260_H + +// ============================================================================================ +// Includes + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void INA260_Init(); + +#endif // INA260_H \ No newline at end of file diff --git a/Firmware/Images/Icons_Settings.xcf b/Firmware/Images/Icons_Settings.xcf new file mode 100644 index 0000000000000000000000000000000000000000..a6c3299c83656a18db07fddddfd04edb2ed7a43a GIT binary patch literal 45221 zcmeHw2Y4LC+5c?6J2hMGxXCug-EzfXY>*oci7253k^pg$%ZH1CMNNnaAwYmQ0TL1j zaRR{sS?=AIEy)FUQ;a3KTgA2{8%%SR?)Lrv=63gPZucam{J-b<;PL92oA>?AyVG~} zop)wOlc!G4PJ3*^q_ju+_3zJcW!R3>ufa8ilO+5!gY%67#2v2Ya4K9oxRy4}NEMF zsS`N{X{k;3SvikS%SxLybK2C2Jp$b)O`b4w+RTRnX}G$F$+XV5cN^PnWVaD%lcvoa zm(w|||J7-of84KuzXARF{dmZb&T0L6Aj0wgMugUl;g}mD?U)~%l|634)ESf0`u9UR zkH>H})92wCQ*+X$&X_PIYZhc4n>lIHtgIYl4DtePk+H(Of|?7JHa#n6+{AG?}gq@ufHY@f5XxtTK_Gh(ZY95 zoet>%{RRvk+Hc6v0oSGt=s$GO;Gu(u{EPSA`q0$LQ)i5u_MgNN&Uj|ljLA7uI$wYF zphi**OaEZ%#D7Wn_AKj(Dhm)^gT8}9wrZ@6vB%$%8h zNAV}(4sHeIxJm{GrTB%YGch2T@J8R0!?9OQqKQwK4=P5Zk*+bLQXUyt5 zZsN@GS$#3ArAK7a@pz?ozJ6GGBp%nZanJPZz7grZycO(WP^|wuohPL6+&wnEp?p0y zF8g1~5n}0U<%8$wU&=~!gy2Qu5!`H#JpWA;7?mbH{vSkeQ+CdTz9X`;r%jzOjz5wE zyj9z$-;h27u8r5Zyf^di7;P7OxQc0vVd>HFk`J}QWt_4Y|934vX{+To+im%6{$crP z>ny+P?Up}qtmR*Khvknbw*2p3u>AX8wfxCrEdQY&S^m?PEdP}zmjBoJmcOvb@}1ws zDGmic!*={l?7QRf>EmZkn+1}!=Rde~IQ~i}xK5nD;VJw=7LMcmzRorcFZ}A~IKKjL z4xJ{@Jq0>Jpc4f;NuYUtd3w%efZ*|RHKVId!(&%+nsCAIBG8Un!qt_I9Eaoi7A`+8 zr~AqPz@1$NKQE_qWq{xgmw%|`Gd3GFFFN2Ew&Uq(Bgaj65I*YwCl;u&O6K?Q#O;jy zpRVM#JhRa&@IaJ~P#K`Ov&$3s8EEIq0KpxufZfq!E42fYQiidhv2~+<9Sgoq^yW}j z`v{en(<9fgi?@W%rVlzF{LaCJ+@zBKPl zV8I`npLgrYg3XW6uaa2sX*$rfJF8RkDOXBjb@C!wrF3J#S7?_%g#{BnqF1kC!KqZ; zp(zV?K277VWWkZO7l$@u!5eBX4e!i?SAItKwP3-CbgEMt3pOdG7h194Z|IYx4y;aD zL(Ak=@K@7vxjhTMNPCmouwY6Fz0{5cv*=V>+i(Q;U%`UcU8G`tzWGvW0y9&d)8_|^ z>Ed;*nVDP@AbK}}(VGD>Ym!?rQ|jj%7#wu&b2-35AJO%`fo4Cc3kwxd9{~Hw=*vRS z(PYraObPTY^j3hGCoiS5P%AnB^2^WrvCxsA;bS3#4uM`p-9TSK+d%)Bz6Uy;mVy2m zO$Ys5dIR)*^gGZq=uyzu)89b9Om~3pPPw30Q99@jv=Vg9B?ELzDl}NAJ?-w#Lak{F z=-cT}pgYhi(7&e#KzFBiLGL%O06m=kq_a>OeLR4L?xg2H=g{+@AEqgwKcQZr-=tw0 z3-zN92eQyMY6|*qG!wXS@i=-w``S+vzzm@!2zZ5_h0v2US!KcQwO_OVvz6MbJf}IJ zJB0QkU1-Vp z4<5p3vP_{f+1e0RJNN>9Iy?0mR_CwSIXPh{8u!XR{Q1eS9Upu25#wh*9G-KDgHJdF zq5MItZ-htCH)im;f@d~*B_EE`5h?=|clO|ud=a#BWq{xgSBm`>jU9YuvxDqx+V_6? z(%bXrzxmtjTRNt*VCsFjCle@G{qFruda%%l+)GUU77iv?XAe%Hl`CZuUci$ z+1l-||LUjr|8UY1f7$f4LFTH??O8~gaZaOPeDg13 zk`c08A$kzRRp(?fcl(kVJqG0GKms2EIoCdk(JD@K2h=u*+iR}?)%8o6XkH?t??8Go zBED54x(WUS$ePz+NZJm8q9%+6BA`bKaR?%K-z1JGU4yR;N0PrS30y{^gh^|0Y3!)ZNS@!wga9Eb|&B# z;XejANE8J81lSh={~i8=Eto>UrhHs?WPS}0G{JeTBS^d7+VHnJ7~S( zXvKl4xE&351L$FB>20`Shtd>aQ)bG0AX$WtF$SU2Es!RF9)(`Sd)QZLO(2PW+w*Hk zE=*!(8VIwvNeWKm zcm!x3QcvE??@7V)5m*CiPZFM)b`_xZ;Wcaa`UuqFR;ahmWq9JgnxXI~ZrXW{cEWSm zVK09+2jSTqu?5tgR(M{M7UPjFxJ6E3A$eq>M&`VvD{#|;{JB5!+p*#2{)ShMBj9XS z2fXd(nL3@lu=StMJ~(O8^e5+ico9Rz!uA+LhHS-XQZ%Y7-gCJZFvgsHXIKyD0r$$5*>_H-`JuOe zIS5+S)Y`6Ou4#k*kzU)4%*t-fSlt{#?}hp?pYXh0!0%0ah)#4%Wx-q`1-eT(;5>er zv6P224MR|Z0Hv@mT7MT=t~lf1 zF~d3gJqvZ4)lFfcCNoB%ag_V-M;nDk&1iyO1axGfqjVGjb1B#vGrR|g9)Q<5NOK{8 zppHz&NE<99=uj;96wy=gGKdNl1pJ>1Y{x=P?|BqCel&Q5=ymzgU_Mbkyw{12C!ujVA*&A zs$&-xe1Yf*7$dqJ^`S1hFnY>I=228IJ?sxxj;Ty+^Sn7hkr4#sVa1UJFtIJscpebG z2UZuWKIs|Y&)C(Al>SQ;xoa|4%jY$K#u6hxqUD=&(ejjS<<$ub=QJBR9TnuIiry5? zX>gRvsIxYjo2G;?p3S$l(bPHd|3{9M`?YXmxf00N9yNK7r3d2V_<{Oy6Y)JC+~Udb z7VUY&_utn%H1`H-M6I_b8>ssR+w8y3ar}N2>B(sG2{FABIgRw_@#xXxygj;$(36Fy z!+LfO@MkCCAkp2;tf%YXa~&V8eeMv^=PAt@W#PFSj|s+vFYqLOKCU$esJoxUgZn(6 z+Wb=vx7`+a|0F6`p2vgx^La z?~fjs0yAgZ=?kk23Z7grtt~9$@+}3SBnpN$+$?uz=IFi6$ozODj9@AMFzDii;{3&n z^GhyZF8fw;XH4CXs#IrgeW;%TqpLDt)^<#P5BEr8=Fl^kSBKu}gIP%5cS4v~e|BvL zs6$_X`e-2L=Yu~6^?AQ`%xrxU)SnGlA$)IuI^GI4Gr17j)h}A%K?Aa0YQty}fEVG< zfj^#G!asv?V7=0YnMxt3Q;86MoZAaJVS3+z+k76uW2PJj@r(A1euVzQ{s9 zWcI9#VPg$|UjcX){wm~g8Ul_PD1}iDGT zdI_`Irk?^TrhW=BEQj_81q6pd8`^ADN?u}w&0^n3U@F!|-c|2<3}Do^)9H&|}E zBfn<8iZ0ZG7dsD@#6>_(x4M$iJs?6IVa@4eBIs`PJqe~D%7$eUwlQ;`bQRJ9Fa^Lw z_~W}_&E}1&cMPoAXm1>TS(z>MV4*gfgDDgWZff0w(eIiO{TBWl%MZ2Q6b{?iYBpaK zfus?Z><`HVNW!0E`CO8Ramlb1A_GqocYIt@zdLR^yck_w1OIIrjQI91;ks&)z&K?r>f8hULQ&FZsvzVJTz#v&69jSwh$;tk+lt^ndC*@eDv5gIHj! z%6g8~m=At$I0LRPoDP=`r@|%LE(yLe)<9SQa(?(e@Yg}+TJR}M9-9o8f_MYWk1%zt z%%rg}wc7dhk4+56Z$$V6$nmtS^7s%g@&@AL`EleqtwC1Acs{w);CyyGJU$=pb$BZ* z32|HL@Hhfv6W|=4-y03*@$occN-FzBgLt zRKzdlqnVITk!~)Orv>WYDO9!DS>eK5lFd!ykzKAy+eIKAoceDL}a z^TXre={jX}m&uQG#WM1Ii1(+4?~T?`D&iOO(M-svNH-VC(*pJHl&#@Df2NAsqV1C4E1BqnndpO==!2Q)gPG`qndpO==!2Q)gYXj&?njuKi9VQ# zK4|CHpNT$*IE)C7_5iQjybs|bZy-KVp3@p+MU3Z@I}Off$HU|E;a-Qg!qCU;a2`h> z6MZnk^LwM=JU*Vs*f_oE@O<$45%a_2;psYMbeGAGbj33Ae2Dj_hVPBmQ7YmW^U+Mm zr${#!%F_b%@06|KK7u}o_!H3n-QW_@R$btdGtmdp?@}|-2Q#@DGSueH@?I1wf3pqD zlTAxus4Q)YsrM{c;d^Zf9w(Xw?oFary;u-N_&2dM0Im-=Pyd%Rk5xmgSTjaU+{*M` zuL;5TU~|G0y*oFV)^-Qg{!BW|tgyJOAo@ek>*|&eeUuPjbw430_4UMr`y*)BFvhk& zL$yPD!#@dq*%uanp)ac&a)Ic_x-Fj0>V8agVTfvrWAU)x8-KeJ-k5o>r9p-K717D| z3cK_$QSG{idtn8pQ}zx_#cTgQ5Omw@Pe5OIZ7`y5`rTKd{LwrtV0lV8Lx!hZ3o-cG*pjS7XNY z<-FT8MEW)ia5@D`-kQ=DwlVGY1z&-?uqLYo=WctWM5ns_C_k#}94e1#T?Sm2-bM4X z3tBqXu-~~OU4tFw>g#28)(*m!5T}{28aq~-Q1=K?MFNuARQmRhd_pT?3HRqPINghy z?0$jx%6qhhVa&erf*qLV4GgZqg0>os8ae#A7&VrKZYA2MVVZ~nK5MYLu|$V_q6jeG zF>DP$L$yLXcGtkeZUT)gnhR{_Li4My$7CZd zHZ*u2>?|nfBPhy>@M4nPgK=Xsq>APaHmydd+!BOobf|bU(#|5<1OeFm|BBops$Hmf zF?V&^E~5JoSFc(+(@aMdqu+`msE47L?P0%CI0$79ON#Y?4J3cXP6_p?I<)UD-X(Z? zu@YvpGbq3fXsD*AiJFQHg~HvBu%9A~r=*EtX#W;km%5?6hLChPvtq=smhtMfODg6Y z)~#^kpxEJR62qFaV7P6&@TQ$3RvD(MYtRVQO=CgyBp6)p6RRH+){(|+8XsQCYhX~} z14a@Cj3jHocp6(Fz+v_9X$&9m)__A-9D}jqL(Dy~u%1KoVG^s&sKqR^UsqP!FAvXk z26holtCfk)bU93zADgw)uo2-qhkB5C=sT$_r2XJ8UAKh(@&oNAK4;0W9iQ|y8IR4M zlOLM-@QjIR6J};V4k%^<$R~d?2XTFyCW3sEu5b;SDKHM10fIYwA~@(p(9V?sf;(J; z>?eAs#AyKM=K z3Fhlf+p$acd`@)!cWqj*OKpC49){T;!0wT-5TSG1V$r$9zyYaPuWO5KJ!Wn~OIF+U zC{|If53q|J7Meun!VUpeJL(8gaYtB(u0~vcPlS9ogDH&pXY*vWEc6y72~BeNMIZEwPy!pxCpfUju|;5qC+!b^1|(P~L% z2lZ`uO>8bDx|ohV*(McWUw7grGCMIg_#7UpJPecDbZm)~i^v?x*ZmLCm+cgG4r`x( z!kXpi^He0W^S{IE^e=zGDD?-Ko!d(1uF4vkM=?!1Fe7{sS+h(u)co<1t6G5=bJ&W z*?GzX*X}EN8*BDEs0xDLC%RK-=dQ&&>?XbEJT!0$JNE}{J?d)Qh=~+6v9(mIrKcGypd!3_`e$X`;_Ha< z`g>WE`s(cBMq0_(r}Q$^f-V~nb`9^mh@nc;hY<}xd3r+gLa}>b z4GO!Pe}TP#;C>B5smv~-%CAGV`#}sX*#@=0mELW`Ld$70>J%+K0Yd$;vj#ng3&9IO zXbt5;Xe+IP5VnL&f)MgF`BtL-5JK8NMiR}wravIT*XV2Bw|@*vtQFUH(X{9v=Z?{* zgVBEr&^T?_+3TP^pgUiCmX4vT^NeM{U8}J3-!sYFwet*~>bC4W8urtjyMTNbg}fdS zwL~6Kk9VHMGxK*H##R0Apw8ZhdPIquvP<*~HrO*#%?FNW-vQ{H4(lWX#w46aJbr_?u82J*kBeq$XA_% zlTmlD)#H^u1zh6Sv>4n%`Z^Jn@_SS-cE6+Q=b$gQxkL-Vy-R0Xpc}pfH36GjZ-Dt6 z17zxFR2t}m)!kD1EESpsV*Ono7R1=}AcnpTM7QGoc^k~x3Fv62>0EjbRyXJz)pWq9 zGyFVNrgdX=oh#}5aEwvouohMiKe=@RJ< zLxoPpkT@ws=cnRHl;}*-Bf+evXb(E<)bnIc!dQAcMwKP4P`$Jlo16O39t?4%s3j}VyY4lBLx6ORWvnIuNpM9I&{w+`*;TjgUdkX+3Gi+zS{fGUA zgZ7mHpF3Q`-m?7IxBqPEhwN;tQUCLs*XPZ9{Wt$JsulXIJm$4hY>6!S<0u*S{1#7F zVzXq$FPnG8ZihK%TVUhlOHDeVD?L!t1}f%#c;Po$1hw+K9}YVW7GUAj>~$2Ar<2e2 zzspa-y9YdX664yD9$3=2`m{#1ryoT#A*A*$eA6?j3h(bT{3DB@=P;GK_{&5r1tXB| z!uvJp>5Kd^zXnT6y*>j~c@6g8h6Ax%YarIZ%ujn_vtScWt%2Hah3Oc}*8w?^G44 zGyDwjuc9_8HN5_`O4P<5f$)9fe}V+|veRJjm_1W}EGG4be-ixF!1+#O9)7he{DctB zQy2xFr%(}2p#mxV0SGS-Pl4z22a$YY3C|qC^SOuT^In8K4;fz8Usz?$X@|15%X#?$ zURJD7hRZq%{`?+{7Qjc{n60?FSuJ%#{hb13wm^-RAS@jlETydN6^nXcQqpsA#r7-- z{bc|`K0zD&5&mz${~9fNz6UHHJ+UX5ehuVB_%A~O>6j<@6u)I1N`WaXEk?QOS_09r zl1dr4Dct(wk+~aDRW*2BX#M+ZC`$#{8v$n_jxrgWIerP^uz`@?2>AqCPe)cl=fj(m zu#ii=Q6)a!qh@0*uK8IIKL;Xj!;&xdsI|vhZrvC7zHk!K-zp;#zF7NJDhAV+K%DP` zmuW|+kaf>ssC-zX^B5$hU)SNAfR2bI{Q{zU9{Ny|Y6zF$VGGK=Z)}NJUPj67syyPA zeF3U7_q}|BjE&$eMoxM5&+okR=VzykXu-!wTp70GZ=gi}DWWwSodxz=`MD?m{FLw7 z=I<3=X5kunPGB4|0|a;WduS9t=EAu$KyZg^R1eGNf|RSwSMrnv%0gw4vRGN7ELD~% z%as+%N_myE8ec#(5U#Ao&f5mV!n5{YG*?j)c4c@8t$1lnsrA zQ-Rz_3{rvAh=g1~jYud3vCmj+IgrZ&Y^8~L3cV6iq11?kTu6;bV4I5Yq${hG)yf*D zHhC_TLKrX_k&ue;)m>z?h!=-kM2$!&MGeQG6wyYx!8DX2X`|$kP}a%lIaW!OB6%Y< zBB5+_Mm?t-u`$5xv`Mzd#rhB{-`$|h^q zv{`CILf%Y`NGO~68=(F)l+Cn7ZbU-bA~hl*Z=psclr0VCLfL|^85_)}vPF7d5+sy- zdA(SlDCrjYeQHEPc|Teg@nTTkr>(O66!Fp5n}+hfv{h-P~xES200F@Y`}97?#W_W>IRB~Y8$+g+6JubZq@K4i1%w7 zr1feT)i-OrZxx{q3$zXLdPP9>A}x$6>*YA8x?b|2`UZ79#X+_8JO@@C4Z9P^Y z;-FH#5(mX5+c>C_FU3J|Xagfw;?DR43yjx80llb*uwaBvo?LBa<~E?;Mi&pTGvi|Xo*<&DRwDP~sj zK&$x>9SKo7LS=yB&bA7`vLC%T&K<5hZm@hV82H4$H}J9lqrivsfluJ% z575WM4WP$U2Kmr%|z#oY-@B!`d37oXY5IA{{E^x{oP2ki$s=#S`6oJ$C z$O32VkpvEFGy><}%`y(*~cGE7Oz)8Cdfs=RX0tY2V;M85Jz-hY_fzx-%0%z=! z1kSgM1kS(9DGPG7i+1|$l5tMj=@U44ry+34PF>)j@Ccl?Qx!OUry_91PFdi5J0*eh z?<9c>?6m5b=OnNb>u=#2w>W8sA#hM%1WwtZ37on^6*z5&B5?W+S>TKvlEC?PkihwO z@Yc4{_U|yaGoQfXTo|Uu@Ys1N@X%M7EbutNi%|^Ehu!GIcKK1Xh9q9)mmfu|+g*MX zqmSSJ`lBcxPC1lvFy(-}-^UzU-H(Z|jT`$hZMJFOemO!1_EUsT+%MS@N&CsBlJ{Hj zChw=xO zC5BD;N_3m@muNN>C{b-Hp+vE%#1h%2l1e0-N-iOrN-42&hXVzRlf(H;DUphkY)URp zv?--H!KT#WfK6$|ew)&ZeKutj8#d)D)@{mPtl3ncShcByV#TI#V3SQH6-zdiTuf1F zAFsWXlH_7(Uy@D9`x0$R*#}K2Ld(n-p|RcGrqz8KQzJO~Uxfaq>gHE-b<;V@kL%{# zeVcT1@qAPi?f!T1%jzh;Z0~7@-qSJ8>tTrc(hsoy619DSw2PPx&IW za>|I%>M1=!Yp1jbt)EgOv~fy_(7sc0g!Z43B6Q#sMd*Z6R!I|2C!R_Omzh&k6Nu1K zjXy%mHNFU~)EE(3tUh~9jKxRols@f z6Y^C>Clh#E)^J)nNz8v5ZESNgGXzdydW4ft;;kIvq?73P0>?*8J=d6Tnh_qC5$;eAp7lKtV7oskeU5K_+av?Zv z%!L?Bqov}x@h#OOrL=fjrnwMlnd(BY(&a*wWwHxVmq{)}TShKKU*^=XotI^_T(|4o zL8RrH3z3(rE(B|0E<{}}yAW-;DdtWqdV+F0$U5K<&b0P9d)rDY<%!Q~cWf!8YlxzfjWEpB= zg}#zph_TYjjU!>Kq*Z!2e^EqQrMVD!mFhyUR^~#~Rk91wR!J@dCknd|V->HPXxhdq zTCKYfX|?7;um{40V9m^hsH$B0+G5Ft;G|9$Vl0l963^@syhRu3k#bvzv`BLy@*>rRV5g1?Q5VTBL|Y`e z5FIDhJ9TWO1!SQckrrxpJ2*1(Le+&}$C3+C7s@U~TPV2@eIdCJjP2nTcTzGI(gNLu zNDDL%~2zGM05Osm_W6W$%W{7i1%#FPu6wr*PU)o^mm6qaQ~RDOYnLa<1w^lw8GysJXHW(Q+jhqUYjyj!8?;m6_&3 zu;syp(0lxS;}i0z;~;S{&)5&l$Dq%RGx}%7r^adHlwJb~fj2NC!59>SDAgE)Vi2_& zV^9pDS0m3ZM5@wb5CgLa&4tKSstZx76c?ga$u2~zl3a*hMJ~jsik8x-F{%yBAM{AM zEkru0xe)oJ>Oz#0iVIOs$}U7ZDY+2+Bzch&POV$1>nEiXn%xc#BA-xQh;l-4AvmYp zg=i-v7owja7h;^STHHy=I6=qta36>w(s9j&$j4O|q8wLThK_&5iGbe%z>}3O$lP3y~@` z7a~`vE<~w-Wh30*^pnni6aW52=M_*l`r_%?O`blHRb27B<8Chfs~gFVp?V!y$~ z8RJqClg zq9@uh@d5C+N-O3XzHrU@7ruX=RnPbDv;N^kgl{*OEL*XXE1H-Tg;f=0sk{Wuylf@c zP#sWTDnUOsmoDdutOHsqGPy9WB*VNBBd0G3u_ZAP8cTgkXqlJ0?jxo1AEV6 z6`FA@qCqo`MKGt2=&JmlSWVeNL`~U3L`~U3L`~U3L`~U3L`~U3L`~U3qMEY9M>S;! ziE7H2lZUmPsHW^7QBB!FqMEXUL^Wjxu{33U8Ej>C%v@8B<+-LDi*QXj7U7z5EW$PA zScGfJu?W|cV-c@BQVe?EZwlHjW%_ly}J~ zg`uKtE=(&V7orzNi_K#)3iU`eSUmm%oePl)R2PCT99#%CrVEH(=yActY(u z;qjWAKJu|kB_Hp4zo<|Mkk;0%E86~12_Merqu2QIfBEXqpF^<*|9ukLpLH!&IikVcKw(BX<> z{7DsKR*HkAM_9S$g4JR=gt4bg@!|(DfR>jX@dTI$k6;KbJF2%>4l;TEkE+=TIMTC?NF&I{Kwk^lQ3fEl2GOJ_?9%7;LVP1GXy!Z~HAbK3 zh!&&Ia|GJD>n><6?>ibamoQ@Vc?%Ksc?%Ksc?%Ksc?%Ksc?*fv=efQdtIyjS^cFtB zqOGnb&@N9&IxGBo^H1Ro!}5H+mfJGIX5(!v_Ph~QH@*IfoQd{KgH^tua?pyS8N z$ZPpGadvwnC1V}FsdFLfTG@p_J;xIx-lea_9uXG;BZLcq2|_?HCs|8tFn+i&>=KEn z>s*GvWBBPR{Jap@)jTIl5cZWc6fR>YikxemdJ^w`WwnIUS)>LfWSq{@u!OQEh|^gb zj08u#ti`_t4j-KoKO^D8CmIP4t()J7gk&Gj(m)#F<5}tt$0W0!%62}x59Q}IA|Ztj zXK65vdJboC(!lWnagSArhKJTKXix&*-_~<9ixWrqc#JrQrikJ3k7f}i;vdZ-N;Gsd zOXP?RPuJ$h*znT@tV2BNKbpmnsQ+jdN230tSsaP_j%JC5*LO5aRHDA4S)vj!!^J(C zB`V=QnkBX_;vLQ6m2e-;Vo6xX=~#!NxQ}M>Nj2EN3-w) zGgaE@lFU&150?gZ`*$_v!}Ywg!a`d z9ZK*sKyzoyzRGFm$^gL~u2=7|d@d+{?hya82_xo{gv%dIV0ALG760-_6IflvHhU~o z;}e8$(nk|kj>V5A90Xe_gfd|#OXQ=8sD$&;L=M_ZKX~)QeVO=6p!&Xl8W7rVr!K5}F5QZ9QiwOsOGS~>okN4Sqg)6mPk2#%rlNJ$l{2g51W9!#l_ zJ(yY{c`&VlJQ&vZ(EnrdRza1T2a_sQ4<=VC9!#l}J(yZ4c`&V#JQ&tJT{*$F+~b-D zla8w%Og^r7F#Mxq52hZMJeYQzJQ&u4!_N--a2eXG0(m=5C$JWT=Sjq*6RHQ3PbeNt zIU##6^@QZXv=cBJy3){2V4U<|7%5$tegdXL7p9%S$QF}h?F2U;eiJqG{#@AOLEg@h z=GHv^@`2sSEsloQXDyCO)MqV@O4Mg9j!L+##g^?|48MGkw|Erz<%7Hx*YVev z5Au#2y&gWB`tm{EG3SYMlkw$)ykn1xzI>3keF$}&qqQ#|| z;abEE4&iHd6UIabFvE5!cVtb=nvgSf=8UwP$IW_>i`&sgs&zK7P8_$-1LrmmF4K^W zCC!$B$3(kIvW@e5ktxUaaTQ2zW)UyPJi-7S{*@P8gsik$b-hrmz18 Dry-|m literal 0 HcmV?d00001 diff --git a/Firmware/Images/Image_Bronze_Copper_Microchip2_64x64.c b/Firmware/Images/Image_Bronze_Copper_Microchip2_64x64.c new file mode 100644 index 0000000..7df11a8 --- /dev/null +++ b/Firmware/Images/Image_Bronze_Copper_Microchip2_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Bronze_Copper_Microchip2_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xf833, 0xf933, 0xf833, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0xf933, 0xf933, 0xd833, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0xf833, 0xf933, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, + 0x0000, 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0x1323, 0x8911, 0xab11, 0x552b, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0x9022, 0x8911, 0x0d1a, 0xb733, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0d1a, 0x6911, 0x9022, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x552b, 0xcb11, 0x8911, 0xf322, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, + 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xa408, 0x0000, 0x0000, 0x6911, 0xd833, 0xd833, 0xd833, 0xd833, 0x342b, 0x6200, 0x0000, 0x0000, 0xb122, 0xd833, 0xd833, 0xd833, 0xd833, 0xb122, 0x0000, 0x0000, 0x6200, 0x132b, 0xd833, 0xd833, 0xb733, 0xd833, 0x8911, 0x0000, 0x0000, 0xc408, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, + 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0x0000, 0x0000, 0x0000, 0xc508, 0xd833, 0xd833, 0xd833, 0xd833, 0x9022, 0x4100, 0x0000, 0x0000, 0x0d1a, 0xd833, 0xd833, 0xd833, 0xd833, 0x0d1a, 0x0000, 0x0000, 0x4100, 0x6f22, 0xd833, 0xb733, 0xb733, 0xd833, 0xc508, 0x0000, 0x0000, 0x0000, 0xb733, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, + 0x0000, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0x0000, 0x0000, 0x0000, 0xc508, 0xd833, 0xb72b, 0xb733, 0xd833, 0x6f22, 0x2100, 0x0000, 0x0000, 0x0d1a, 0xb733, 0xb833, 0xb833, 0xb733, 0x0c1a, 0x0000, 0x0000, 0x2100, 0x6f22, 0xb733, 0x9733, 0x972b, 0xb733, 0xc508, 0x0000, 0x0000, 0x0000, 0xb733, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0xf933, 0x0000, 0x0000, 0x0000, 0xe608, 0xd833, 0xd833, 0xd833, 0xd833, 0xd122, 0x2100, 0x0000, 0x0000, 0x4e1a, 0xd833, 0xd833, 0xd833, 0xd833, 0x4e1a, 0x0000, 0x0000, 0x2100, 0xb122, 0xd833, 0xd833, 0xd833, 0xd833, 0xe508, 0x0000, 0x0000, 0x0000, 0xd833, 0xb733, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0xf933, 0x1323, 0x0000, 0x0000, 0x0000, 0x2100, 0xc508, 0xc508, 0xc508, 0xc508, 0x8300, 0x0000, 0x0000, 0x0000, 0x6200, 0xc508, 0xc508, 0xc508, 0xc508, 0x6200, 0x0000, 0x0000, 0x0000, 0x8300, 0xc508, 0xc508, 0xc508, 0xc508, 0x2100, 0x0000, 0x0000, 0x0000, 0xf322, 0xd833, 0xb733, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xf933, 0xcb11, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4200, 0xab11, 0xd833, 0xd733, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0xf933, 0xcb11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xab11, 0xd833, 0xb733, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xd833, 0xd833, 0xd833, 0x1323, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4100, 0xf222, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0xf933, 0x1323, 0xc408, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4811, 0x762b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0x752b, 0x2711, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc408, 0xf222, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xf933, 0xd833, 0x8911, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x762b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x752b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6911, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xf833, 0xd833, 0xcb19, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcb19, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xd833, 0xf933, 0x762b, 0x8911, 0xc508, 0xc508, 0xc508, 0x2100, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0x2100, 0xc508, 0xc508, 0xc508, 0x6911, 0x552b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf933, 0xf933, 0xf933, 0xf933, 0xf933, 0xf833, 0xf833, 0xf833, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xe608, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0xe508, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xf833, 0xf833, 0xf833, 0xf833, 0xf833, 0xf833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb72b, 0xd833, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x972b, 0x972b, 0x972b, 0x972b, 0x972b, 0x972b, 0x972b, 0x972b, 0x972b, 0x972b, 0x9733, 0xd833, 0xd833, 0xb833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0x962b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xd833, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x142b, 0xcb19, 0x6811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0xcb19, 0x132b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0x9633, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xe508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x342b, 0xa408, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa408, 0x132b, 0xd833, 0xb733, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0xe508, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x132b, 0x9022, 0x6f22, 0x9022, 0x8300, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xcb19, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0xcb19, 0xd833, 0xb733, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0x8300, 0x9022, 0x6f22, 0x6f22, 0x132b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x9022, 0x8308, 0x4100, 0x2100, 0x4100, 0x0000, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x6811, 0x0000, 0x0000, 0x0000, 0x6300, 0x8308, 0x8300, 0x8300, 0x8300, 0x8300, 0x8300, 0x8300, 0x8308, 0x6300, 0x0000, 0x0000, 0x0000, 0x4811, 0x9733, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x4100, 0x2100, 0x2100, 0x8308, 0x6f22, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x6811, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x6300, 0xb122, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0xb122, 0x6300, 0x0000, 0x0000, 0x4811, 0x962b, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4811, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x0d1a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8308, 0x552b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x552b, 0x8308, 0x0000, 0x0000, 0x4811, 0x962b, 0xd833, 0xd833, 0xd833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0c1a, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xb122, 0x0d1a, 0x0d1a, 0x4e1a, 0x6200, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8300, 0x342b, 0xd833, 0xb833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xb833, 0x342b, 0x8300, 0x0000, 0x0000, 0x4811, 0x962b, 0xd833, 0xd733, 0xd833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0x6200, 0x2e1a, 0xec19, 0x0c1a, 0x9022, 0x9633, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xd833, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8300, 0x342b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0x342b, 0x8300, 0x0000, 0x0000, 0x4811, 0x962b, 0xd833, 0xd733, 0xb833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8300, 0x342b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0x342b, 0x8300, 0x0000, 0x0000, 0x4811, 0x962b, 0xd833, 0xb733, 0xb833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8300, 0x342b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0x342b, 0x8300, 0x0000, 0x0000, 0x4811, 0x962b, 0xb833, 0xb733, 0xb833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xd833, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8300, 0x342b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0x342b, 0x8300, 0x0000, 0x0000, 0x4811, 0x962b, 0xb833, 0xb733, 0xb833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xb122, 0x0d1a, 0x0d1a, 0x4e1a, 0x6200, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8300, 0x342b, 0xd833, 0xb733, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0x342b, 0x8300, 0x0000, 0x0000, 0x4811, 0x962b, 0xb833, 0xb733, 0xb833, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x6200, 0x2e1a, 0xec19, 0x0c1a, 0x9022, 0x9633, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x0d1a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x8308, 0x552b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x552b, 0x8308, 0x0000, 0x0000, 0x4811, 0x962b, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0c1a, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x6811, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x972b, 0x4811, 0x0000, 0x0000, 0x6300, 0xb122, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0x342b, 0xb022, 0x6200, 0x0000, 0x0000, 0x4811, 0x962b, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4811, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x9022, 0x8308, 0x4100, 0x2100, 0x4100, 0x0000, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0x6811, 0x0000, 0x0000, 0x0000, 0x6300, 0x8308, 0x8300, 0x8300, 0x8300, 0x8300, 0x8300, 0x8300, 0x8308, 0x6200, 0x0000, 0x0000, 0x0000, 0x4811, 0x9733, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x4100, 0x2100, 0x2100, 0x8308, 0x6f22, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x132b, 0x6f22, 0x6f22, 0x9022, 0x8300, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xcb19, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0xcb19, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x8300, 0x9022, 0x4f22, 0x6f22, 0xf32a, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xe508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x132b, 0xa408, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa408, 0x132b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xb733, 0xb833, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x132b, 0xcb19, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0x4811, 0xcb19, 0x132b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0x9633, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xb733, 0x972b, 0xb733, 0xc508, 0x0000, 0x0000, 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0xd833, 0x9733, 0x962b, 0x962b, 0x962b, 0x962b, 0x962b, 0x962b, 0x962b, 0x962b, 0x962b, 0x962b, 0x9633, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0x9733, 0x962b, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xe508, 0x0000, 0x0000, 0x0000, 0xb833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xb733, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0xe508, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0x552b, 0x6911, 0xc508, 0xc508, 0xc508, 0x2100, 0x0000, 0x0000, 0x0000, 0xb833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd733, 0xd733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x2100, 0xc508, 0xc508, 0xc508, 0x6911, 0x342b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xcb19, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xab19, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0x6911, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x752b, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x552b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6911, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xd833, 0xf322, 0xc408, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2711, 0x752b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x552b, 0x2711, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa408, 0xf22a, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xb733, 0xb733, 0xf222, 0x4100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4100, 0xf222, 0xb733, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xd833, 0xab11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa11, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xab11, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4200, 0xaa11, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb733, 0xd833, 0xf32a, 0x0000, 0x0000, 0x0000, 0x2100, 0xc508, 0xc508, 0xc508, 0xc508, 0x8300, 0x0000, 0x0000, 0x0000, 0x6200, 0xc508, 0xc508, 0xc508, 0xc508, 0x6200, 0x0000, 0x0000, 0x0000, 0x8300, 0xc508, 0xc508, 0xc508, 0xc508, 0x2100, 0x0000, 0x0000, 0x0000, 0xf22a, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb733, 0xb833, 0x0000, 0x0000, 0x0000, 0xe508, 0xb833, 0xb833, 0xb833, 0xb733, 0xb122, 0x2100, 0x0000, 0x0000, 0x2e1a, 0xb733, 0xb733, 0xb733, 0xb733, 0x2e1a, 0x0000, 0x0000, 0x2100, 0xb122, 0xb733, 0xb733, 0xb733, 0xb733, 0xe508, 0x0000, 0x0000, 0x0000, 0xb733, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, + 0x0000, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xd833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0x962b, 0x9633, 0xb733, 0x6f22, 0x2100, 0x0000, 0x0000, 0xec19, 0x9733, 0x9733, 0x9733, 0x9733, 0xec19, 0x0000, 0x0000, 0x2100, 0x4f22, 0x9733, 0x9633, 0x962b, 0x9733, 0xc508, 0x0000, 0x0000, 0x0000, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, + 0x0000, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0x0000, 0x0000, 0x0000, 0xc508, 0xb733, 0xb733, 0xb733, 0xb733, 0x6f22, 0x2100, 0x0000, 0x0000, 0x0d1a, 0xb733, 0xb733, 0xb733, 0xb733, 0x0d1a, 0x0000, 0x0000, 0x2100, 0x6f22, 0xb733, 0xb733, 0x9733, 0xb733, 0xc508, 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, + 0x0000, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xa408, 0x0000, 0x0000, 0x8911, 0xb733, 0xb733, 0xb733, 0xb733, 0x132b, 0x6200, 0x0000, 0x0000, 0xb022, 0xb733, 0xb733, 0xb733, 0xb733, 0x9022, 0x0000, 0x0000, 0x6200, 0x132b, 0xb733, 0xb733, 0xb733, 0xb733, 0x6911, 0x0000, 0x0000, 0xa408, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, + 0x0000, 0x0000, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb833, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xf222, 0x8911, 0xcb11, 0x342b, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x6f22, 0x6911, 0x0c1a, 0x9633, 0xb733, 0xb733, 0xb733, 0xb733, 0x9633, 0xec19, 0x6911, 0x6f22, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x342b, 0xaa11, 0x8911, 0xf22a, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, + 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x9733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0xb733, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Computer_64x64.c b/Firmware/Images/Image_Computer_64x64.c new file mode 100644 index 0000000..edf439d --- /dev/null +++ b/Firmware/Images/Image_Computer_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Computer_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4008, 0xa349, 0x4572, 0xe68a, 0x68a3, 0x09bc, 0x8adc, 0x0cf5, 0x0cf5, 0x8adc, 0x09bc, 0x68a3, 0xe68a, 0x4572, 0xa349, 0x4008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8118, 0x256a, 0xc9b3, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0xc9b3, 0x256a, 0x8118, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x6572, 0x4acc, 0x4cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x4acc, 0x6572, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0562, 0xcbe4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xcbe4, 0x0562, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8349, 0x6ad4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6ad4, 0x8349, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa118, 0x09c4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x09c4, 0xa118, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4339, 0xebec, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xebec, 0x4339, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0462, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x0462, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe78a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xe78a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa8b3, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xa8b3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe78a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xe78a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0462, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x0462, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4339, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x4339, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa118, 0xebec, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xb6fe, 0xf8fe, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x18ff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x5bff, 0x19ff, 0xf1fd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xebec, 0xa118, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x09c4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x11fe, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x54fe, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x09c4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8349, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x9dff, 0xffff, 0xfbde, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x34ad, 0x13a5, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x2c6b, 0x4c6b, 0x95bd, 0x7df7, 0x7df7, 0x0bfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x8349, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x6ad4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x8efd, 0xffff, 0xffff, 0xca62, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xa539, 0x3cef, 0x7df7, 0xecec, 0x0bfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6ad4, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0562, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x69ec, 0x0bfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x0562, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x2008, 0xcbe4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x69ec, 0x0bfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xcbe4, 0x2008, 0x0000, 0x0000, + 0x0000, 0x0000, 0x6572, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x69ec, 0x0bfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6572, 0x0000, 0x0000, + 0x0000, 0x0000, 0x4acc, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x0bfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4acc, 0x0000, 0x0000, + 0x0000, 0x8118, 0x4cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x0bfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8118, 0x0000, + 0x0000, 0x256a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x0bfd, 0x6cfd, 0x6cfd, 0x256a, 0x0000, + 0x0000, 0xc9b3, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x0bfd, 0x6cfd, 0xc9b3, 0x0000, + 0x4008, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x0bfd, 0x2cfd, 0x4008, + 0xa349, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x0bfd, 0xa349, + 0x4572, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0xe692, + 0xe68a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xc8c3, + 0x68a3, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x08d4, + 0x09bc, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49e4, + 0x8adc, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, + 0x0cf5, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, + 0x0cf5, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, + 0x8adc, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49e4, + 0x09bc, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x29dc, + 0x68a3, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0x8531, 0xdae6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x08d4, + 0xe68a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xbef7, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xae7b, 0xad7b, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0x0742, 0xfbe6, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xa8bb, + 0x4572, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x47a3, + 0xa349, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x657a, + 0x4008, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x2eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x6110, + 0x0000, 0xc9b3, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xaffd, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x0eed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x29dc, 0x0000, + 0x0000, 0x256a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6dfd, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x6aec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x069b, 0x0000, + 0x0000, 0x8118, 0x4cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0xf8fe, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x1af7, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xe228, 0x0000, + 0x0000, 0x0000, 0x4acc, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6dfd, 0xb7fe, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x1af7, 0xaaec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49e4, 0x0000, 0x0000, + 0x0000, 0x0000, 0x6572, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0xaaec, 0xcbec, 0xccec, 0xccec, 0xccec, 0xccec, 0xccec, 0xccec, 0xccec, 0xccec, 0xccec, 0xccec, 0x2eed, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x3cef, 0x3cef, 0x3cef, 0x3cef, 0x3cef, 0xb1ed, 0x2eed, 0x2eed, 0x2eed, 0x2eed, 0x2eed, 0x2eed, 0x2eed, 0x2eed, 0x2eed, 0x2eed, 0x0ded, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x27a3, 0x0000, 0x0000, + 0x0000, 0x0000, 0x2008, 0xcbe4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x70ed, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x14ee, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x4008, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0562, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x34f6, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0xb8ee, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xe692, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x6ad4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xd9f6, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69e4, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8349, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x8aec, 0x7cf7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0xabec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x657a, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x09c4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x2eed, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0x1bef, 0xb1ed, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49dc, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa118, 0xebec, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x49ec, 0x49ec, 0x70f5, 0x91f5, 0x97f6, 0x9eff, 0x9eff, 0x9eff, 0x9eff, 0x9eff, 0x9eff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x3bf7, 0x35f6, 0x14f6, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x0231, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4339, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x49ec, 0x9dff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0xe461, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0462, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0x8aec, 0x9dff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xe69a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe78a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x4cfd, 0xd8fe, 0x1aff, 0x1aff, 0x1aff, 0x1aff, 0x1aff, 0x1aff, 0x1aff, 0x1aff, 0x5cf7, 0x5cf7, 0x5cf7, 0x5cf7, 0x5cf7, 0x5cf7, 0x5cf7, 0x5cf7, 0x3bf7, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xc8c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa8b3, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x28d4, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe78a, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xa8bb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0462, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0xe692, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4339, 0xebec, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x046a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa118, 0x09c4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49dc, 0x2239, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8349, 0x6ad4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69e4, 0x4572, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0562, 0xcbe4, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x069b, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x6572, 0x4acc, 0x4cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x69ec, 0x49e4, 0x27a3, 0x6110, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8118, 0x256a, 0xc9b3, 0x2cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x6cfd, 0x2cfd, 0x69ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x49ec, 0x29dc, 0x069b, 0xc228, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4008, 0xa349, 0x4572, 0xe68a, 0x68a3, 0x09bc, 0x8adc, 0x0cf5, 0xebf4, 0x69ec, 0x49e4, 0x08d4, 0xa7bb, 0x269b, 0x4572, 0x8118, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Energy_64x64.c b/Firmware/Images/Image_Energy_64x64.c new file mode 100644 index 0000000..457560b --- /dev/null +++ b/Firmware/Images/Image_Energy_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Energy_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0xe910, 0x4e19, 0xb121, 0x1422, 0x572a, 0x9b32, 0xfe3a, 0xfe3a, 0x9b32, 0x572a, 0x1422, 0xb121, 0x4e19, 0xe910, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4300, 0x2d19, 0x362a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x362a, 0x2d19, 0x4300, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x6e19, 0x7932, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7932, 0x6e19, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c11, 0xdc32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdc32, 0x2c11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe910, 0x9a32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x9a32, 0xe910, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6308, 0x582a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x5f3b, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x582a, 0x6308, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa708, 0xdd3a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xff34, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdd3a, 0xa708, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c11, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f3b, 0xff46, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x2c11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb121, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3f35, 0xff46, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xb121, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x362a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x9f33, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x362a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb121, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f35, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xb121, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c11, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf33, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x2c11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa708, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf3d, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xa708, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6308, 0xdd3a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdf33, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdd3a, 0x6308, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x582a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdf3d, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x582a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xe910, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xff33, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xe910, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x9a32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3f3b, 0x1f3e, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x9a32, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x2c11, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f34, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x2c11, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x2100, 0xdc32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3f3b, 0x3f3e, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdc32, 0x2100, 0x0000, 0x0000, + 0x0000, 0x0000, 0x6e19, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3f34, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x6e19, 0x0000, 0x0000, + 0x0000, 0x0000, 0x7932, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3f3b, 0x7f46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7932, 0x0000, 0x0000, + 0x0000, 0x4300, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f34, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x4300, 0x0000, + 0x0000, 0x2d19, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3f3b, 0x9f46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x2d19, 0x0000, + 0x0000, 0x362a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x9f34, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x362a, 0x0000, + 0x2100, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x5f3b, 0xbf46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x2100, + 0xe910, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdf34, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xe910, + 0x4e19, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x5f3b, 0xdf46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x4e19, + 0xb121, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xff34, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xb121, + 0x1422, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f33, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x5f0e, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1422, + 0x572a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3f35, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0xbe0b, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x572a, + 0x9b32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x9f33, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x3f0e, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x9b32, + 0xfe3a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f35, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x5e0b, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xfe3a, + 0xfe3a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf33, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x1f0e, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x1f3b, 0xfe3a, + 0x9b32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x9f3d, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0xfe0a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf32, 0x1f3b, 0x1f3b, 0x9b32, + 0x572a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdf33, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0xff46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0xff15, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf2a, 0x1f3b, 0x572a, + 0x1422, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf3d, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0xdf46, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x9e0a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xbf2a, 0x1422, + 0xb121, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x3e1a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0xdf15, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0x9419, + 0x4e19, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1e1a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x5e02, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5509, + 0xe910, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1e1a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x9f15, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x0e09, + 0x2100, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1e1a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x1e02, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x2200, + 0x0000, 0x362a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1e1a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x5f15, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7c09, 0x0000, + 0x0000, 0x2d19, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1e1a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0xde01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3609, 0x0000, + 0x0000, 0x4300, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xfe19, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x1f15, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x8800, 0x0000, + 0x0000, 0x0000, 0x7932, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xfe19, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x9e01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7c09, 0x0000, 0x0000, + 0x0000, 0x0000, 0x6e19, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xfe11, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0xdf14, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5311, 0x0000, 0x0000, + 0x0000, 0x0000, 0x2100, 0xdc32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xfe11, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f0e, 0x7d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0x2100, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x2c11, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xde11, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f14, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3409, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x9a32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xde11, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f0e, 0x5d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0x0100, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xe910, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xde11, 0x3d01, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x3e14, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0xef08, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x582a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xde11, 0x3d01, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0x5f0e, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x9b09, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6308, 0xdd3a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xde11, 0x3d01, 0x7f06, 0x7f06, 0x7f06, 0x7f06, 0xde0b, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x6600, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa708, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbe11, 0x7f06, 0x7f06, 0x7f06, 0x3f0e, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0xee08, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c11, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f06, 0x7f06, 0x7f06, 0x7e0b, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3409, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb121, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f06, 0x7f06, 0x1f0e, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7809, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x362a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f06, 0x7f06, 0x1e0b, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7b09, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb121, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f06, 0xff15, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7809, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c11, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7f06, 0xbe0a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3409, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa708, 0xdd3a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xdf15, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0xee08, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6308, 0x582a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x7e0a, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x9b09, 0x6600, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe910, 0x9a32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf32, 0x5d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0xef08, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c11, 0xdc32, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf32, 0x5d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x5d01, 0x3409, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x6e19, 0x7932, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf32, 0x5d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x3d01, 0x7c09, 0x5311, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4300, 0x2d19, 0x362a, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0x1f3b, 0xbf32, 0x5d01, 0x3d01, 0x3d01, 0x3d01, 0x7c09, 0x3609, 0x8800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0xe910, 0x4e19, 0xb121, 0x1422, 0x572a, 0x9b32, 0xfe3a, 0xfe3a, 0x9b32, 0x572a, 0x1422, 0x9419, 0x5509, 0xee08, 0x2200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Fad_Logo_Background_160x160.c b/Firmware/Images/Image_Fad_Logo_Background_160x160.c new file mode 100644 index 0000000..6b00a0b --- /dev/null +++ b/Firmware/Images/Image_Fad_Logo_Background_160x160.c @@ -0,0 +1,171 @@ +#include + + + +const uint16_t _Image_Fad_Logo_Background_160x160[3 + 25600] = { + 160, // Image Width + 160, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa210, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, 0x0842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x18c6, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x518c, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0xeb5a, 0x6d6b, 0xc739, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3084, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8210, 0x34a5, 0x5def, 0x5def, 0x5def, 0x79ce, 0xef7b, 0x2842, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcb5a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6529, 0x18c6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x59ce, 0xcf7b, 0x0842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x1ce7, 0x494a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc739, 0xfbde, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x38c6, 0x494a, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x59ce, 0x2421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x694a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xf7bd, 0x2c63, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xb294, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x2c63, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xdbde, 0x8e73, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x14a5, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x1084, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x1084, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8e73, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x34a5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6d6b, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xeb5a, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4529, 0xd7bd, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xf7bd, 0x2842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe739, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0842, 0x3ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xf39c, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x96b5, 0x4529, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3ce7, 0x8a52, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x75ad, 0xc318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xcf7b, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x96b5, 0x2421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcf7b, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0x14a5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x7def, 0x494a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3ce7, 0x6d6b, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x96b5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8e73, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xdbde, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x38c6, 0x2842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4529, 0x9ad6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x9294, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x494a, 0x9ad6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x38c6, 0xa631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xcb5a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x494a, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x3084, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcb5a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x694a, 0x9ad6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x0c63, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0xa631, 0x718c, 0x7def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x4d6b, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa210, 0xeb5a, 0xf7bd, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8e73, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0x8a52, 0x3ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6d6b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0x4d6b, 0xfbde, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xeb5a, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4529, 0x9294, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x694a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x494a, 0xd7bd, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3ce7, 0x6529, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0x1084, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, 0x2421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0x2842, 0xc318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xeb5a, 0x1ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xb6b5, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0842, 0x9ad6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcf7b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2421, 0xf7bd, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe739, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa210, 0x75ad, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xdbde, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x518c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x718c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8210, 0xb294, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x0842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8210, 0xf39c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd7bd, 0xc318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2421, 0x38c6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xef7b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6529, 0x3ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6529, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcb5a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0421, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x75ad, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x494a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6529, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x96b5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x518c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0421, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x7def, 0xc318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6d6b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x2421, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0xcb5a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x75ad, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x6529, 0x2842, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2421, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x18c6, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x518c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2842, 0x0000, 0x0000, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6529, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xf39c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xa210, 0x0000, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x694a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xaa52, 0x0000, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xef7b, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x9ad6, 0xa210, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc739, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, + 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0xfbde, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x4d6b, 0x0000, 0x0000, + 0xcf7b, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0xf7bd, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xdbde, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0x75ad, 0xb6b5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3084, 0x4108, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x494a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x7def, 0x4108, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0421, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xa631, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x7def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x694a, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x518c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6d6b, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6d6b, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0842, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xb6b5, 0x8210, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6529, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8210, 0x18c6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6529, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x75ad, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x694a, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x75ad, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2c63, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c63, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2c63, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2c63, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x55ad, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2842, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8210, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x55ad, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2c63, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xaa52, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2c63, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcf7b, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2c63, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x75ad, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xaa52, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x75ad, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6529, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0x59ce, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6529, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x1ce7, 0x4529, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc739, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6d6b, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcf7b, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xaa52, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x7def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x694a, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0421, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x7def, 0xc318, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2842, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x9ef7, 0x4108, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x518c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcf7b, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8210, 0xd7bd, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xeb5a, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4529, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2c63, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x79ce, 0x4108, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0xfbde, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3084, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc739, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x694a, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8e73, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8210, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0xe318, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc318, 0x1ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x9294, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0842, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2842, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3ce7, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x694a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xae73, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x96b5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0842, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x14a5, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8210, 0x9ad6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcb5a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x79ce, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe318, 0x7def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x0842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x9294, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd7bd, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcb5a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x694a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4529, 0x3ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0x96b5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x694a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x518c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x9294, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xf39c, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xae73, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0x7def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x694a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xeb5a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2842, 0x3ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x34a5, 0x8210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe739, 0xfbde, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xa631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcb5a, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2c63, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x4d6b, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x9294, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0xae73, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xfbde, 0x2421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0421, 0xf39c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xc739, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2842, 0x18c6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcb5a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0421, 0xb294, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8e73, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x8a52, 0x9ad6, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x718c, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x8631, 0x59ce, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd7bd, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xa631, 0x718c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x75ad, 0xc318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0xaa52, 0x34a5, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xf39c, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x4529, 0xef7b, 0x9ef7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x55ad, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0xcb5a, 0xf39c, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x8210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0xc318, 0xcb5a, 0x8e73, 0xfbde, 0x3ce7, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd39c, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x2421, 0x8210, 0x8631, 0x8631, 0xcb5a, 0x6d6b, 0x55ad, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcf7b, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x7def, 0x7def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x1ce7, 0xaa52, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xd7bd, 0xa631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x75ad, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6d6b, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xb6b5, 0xa631, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x6d6b, 0x8210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xb6b5, 0x8631, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x59ce, 0xaa52, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xcf7b, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xef7b, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xdbde, 0xef7b, 0x0421, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x18c6, 0x0c63, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x14a5, 0xaa52, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x96b5, 0xae73, 0x6529, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0xf7bd, 0xcb5a, 0x0421, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x38c6, 0x75ad, 0x0842, 0x2421, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x8e73, 0x0c63, 0xe318, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8631, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x5def, 0x3ce7, 0xfbde, 0xfbde, 0x8e73, 0x2842, 0xe739, 0xc318, 0xa210, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa210, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0xe739, 0x4529, 0x4529, 0x4529, 0xe318, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Forest_Pine_Midi_64x64.c b/Firmware/Images/Image_Forest_Pine_Midi_64x64.c new file mode 100644 index 0000000..485ed8a --- /dev/null +++ b/Firmware/Images/Image_Forest_Pine_Midi_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Forest_Pine_Midi_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x872a, 0x662a, 0x662a, 0x462a, 0x462a, 0x662a, 0x862a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa72a, 0x662a, 0x0522, 0xa419, 0x4311, 0xe210, 0xa108, 0x8108, 0x6108, 0x6108, 0x8108, 0xa208, 0x0211, 0x6311, 0xc419, 0x2622, 0x872a, 0xc82a, 0xc82a, 0xe82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x0000, 0x0000, + 0x0000, 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0x0522, 0x6319, 0xc208, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xc208, 0x8419, 0x2622, 0xe82a, 0xe82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x0000, 0x0000, + 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0xa62a, 0xa62a, 0xe421, 0x0211, 0x4000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x4000, 0x2311, 0x0522, 0xe82a, 0xe82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x0000, + 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0xa62a, 0x2522, 0x0211, 0x2000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4100, 0xa108, 0xc208, 0xe210, 0xe210, 0xc208, 0xa108, 0x4100, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x2000, 0x2311, 0x6622, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x0000, + 0x0000, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0xa62a, 0x8419, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe210, 0x8419, 0xe521, 0x2522, 0x662a, 0x862a, 0x872a, 0x872a, 0x872a, 0x662a, 0x4622, 0x0522, 0x8419, 0xe208, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x8108, 0xc519, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x0000, + 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0x0211, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4000, 0x6319, 0x2522, 0x862a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xa72a, 0x2622, 0x8419, 0x4000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2311, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x662a, 0xc208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6319, 0x462a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0x672a, 0x8419, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe208, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x662a, 0xa108, 0x0000, 0x0000, 0x0000, 0x0000, 0xa108, 0x2522, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x862a, 0x8419, 0x8419, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc72a, 0xe82a, 0xe82a, 0xc82a, 0x6622, 0xa108, 0x0000, 0x0000, 0x0000, 0x0000, 0xc208, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0xc208, 0x0000, 0x0000, 0x0000, 0x0000, 0x2311, 0x862a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x862a, 0x6108, 0x0000, 0x0000, 0x8108, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xc82a, 0xe82a, 0xe82a, 0xc72a, 0x2311, 0x0000, 0x0000, 0x0000, 0x0000, 0xe208, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0x862a, 0x862a, 0x862a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0xa62a, 0x0211, 0x0000, 0x0000, 0x0000, 0x0000, 0x6319, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xa72a, 0xc72a, 0x8419, 0x0000, 0x0000, 0x0000, 0x0000, 0x8419, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x8419, 0x0000, 0x0000, 0x0000, 0x0000, 0x2311, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0xa62a, 0xa419, 0x0000, 0x0000, 0x0000, 0x0000, 0x6319, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xa72a, 0xc72a, 0x8419, 0x0000, 0x0000, 0x0000, 0x0000, 0x8419, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x8419, 0x0000, 0x0000, 0x0000, 0x0000, 0xc519, 0x082b, 0xe82a, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x2522, 0x6100, 0x0000, 0x0000, 0x0000, 0x2311, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x862a, 0x662a, 0x862a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x872a, 0x8108, 0x0000, 0x0000, 0x8108, 0x872a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xc72a, 0xa72a, 0xa72a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x2311, 0x0000, 0x0000, 0x0000, 0x6108, 0x8722, 0x082b, 0xe82a, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0x862a, 0x0211, 0x0000, 0x0000, 0x0000, 0xa108, 0x862a, 0xa72a, 0xa72a, 0xa72a, 0x0522, 0x6108, 0x0000, 0xc208, 0x462a, 0xc72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x872a, 0x8419, 0x8419, 0x872a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc72a, 0xe82a, 0x662a, 0xc208, 0x0000, 0x8108, 0x4622, 0xe82a, 0xe82a, 0xe82a, 0xc82a, 0xa108, 0x0000, 0x0000, 0x0000, 0x2311, 0xe82a, 0xe82a, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xe521, 0x4000, 0x0000, 0x0000, 0x2000, 0x2522, 0xa72a, 0xa72a, 0xa72a, 0x862a, 0x6108, 0x0000, 0x0000, 0x0000, 0xe210, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xe82a, 0xc82a, 0xc72a, 0x0211, 0x0000, 0x0000, 0x0000, 0x6108, 0xc72a, 0xe82a, 0xe82a, 0xe82a, 0x6722, 0x2000, 0x0000, 0x0000, 0x4000, 0x2622, 0x082b, 0xe82a, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa62a, 0xa72a, 0xa72a, 0xa62a, 0x862a, 0x0211, 0x0000, 0x0000, 0x0000, 0x6319, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x662a, 0x0000, 0x0000, 0x0000, 0x0000, 0xa108, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc72a, 0xe82a, 0xa72a, 0xa208, 0x0000, 0x0000, 0x0000, 0x0000, 0xa72a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x8419, 0x0000, 0x0000, 0x0000, 0x2311, 0xe82a, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa62a, 0xa72a, 0x0522, 0x4000, 0x0000, 0x0000, 0x4000, 0x662a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x862a, 0xc208, 0x0000, 0x0000, 0x0000, 0x4311, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xc82a, 0xe82a, 0x4311, 0x0000, 0x0000, 0x0000, 0xe208, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x872a, 0x4000, 0x0000, 0x0000, 0x4100, 0x4622, 0x092b, 0xe82a, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa62a, 0xa72a, 0x6319, 0x0000, 0x2000, 0x0000, 0x6319, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0x462a, 0xe210, 0xa208, 0x4311, 0x862a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xc82a, 0xe82a, 0x872a, 0x4311, 0xc208, 0x0311, 0x872a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x8419, 0x0000, 0x2000, 0x0000, 0xa419, 0x092b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x662a, 0xc208, 0x0000, 0x0000, 0x2000, 0x2522, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xa72a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x6622, 0x2000, 0x0000, 0x0000, 0xe208, 0xc82a, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x0522, 0x2000, 0x0000, 0x0000, 0xe208, 0x862a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0xc82a, 0xe208, 0x0000, 0x0000, 0x2000, 0x4622, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, + 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa419, 0x0000, 0x2000, 0x0000, 0x8419, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0xe82a, 0x082b, 0xa519, 0x0000, 0x2000, 0x0000, 0xe519, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, + 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x4311, 0x0000, 0x0000, 0x0000, 0xe521, 0xc72a, 0xa72a, 0xc72a, 0xc72a, 0xa72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0xe82a, 0x082b, 0x2622, 0x0000, 0x0000, 0x0000, 0x8411, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, + 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0xa72a, 0x872a, 0xe210, 0x0000, 0x0000, 0x4000, 0x2522, 0xc72a, 0xa72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0xe82a, 0x082b, 0x6722, 0x4100, 0x0000, 0x0000, 0x2311, 0xe82a, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, + 0xa72a, 0xa72a, 0xa72a, 0xc72a, 0xa72a, 0xc72a, 0x662a, 0xa108, 0x0000, 0x0000, 0xa108, 0x662a, 0xc72a, 0xa72a, 0xc72a, 0x862a, 0x8419, 0x8419, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xa72a, 0xa419, 0xa419, 0xc82a, 0x082b, 0xe82a, 0x082b, 0xa72a, 0xa208, 0x0000, 0x0000, 0xc208, 0xc82a, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xa72a, 0xc72a, 0x662a, 0x8108, 0x0000, 0x0000, 0xc208, 0x862a, 0xc72a, 0xc72a, 0x862a, 0x6108, 0x0000, 0x0000, 0x8108, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xa72a, 0x8108, 0x0000, 0x0000, 0x8108, 0xc82a, 0x082b, 0x082b, 0xc82a, 0xe208, 0x0000, 0x0000, 0xa108, 0xa82a, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xa72a, 0xc72a, 0x462a, 0x6108, 0x0000, 0x0000, 0xe208, 0x872a, 0xc72a, 0xc72a, 0x8419, 0x0000, 0x0000, 0x0000, 0x0000, 0x8419, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xa419, 0x0000, 0x0000, 0x0000, 0x0000, 0xa519, 0x082b, 0x092b, 0xc82a, 0x0209, 0x0000, 0x0000, 0x8108, 0xa72a, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xa72a, 0xc72a, 0x462a, 0x6108, 0x0000, 0x0000, 0xe210, 0x872a, 0xc72a, 0xc72a, 0x8419, 0x0000, 0x0000, 0x0000, 0x0000, 0x8419, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xa419, 0x0000, 0x0000, 0x0000, 0x0000, 0xa519, 0x082b, 0x092b, 0xc82a, 0x0309, 0x0000, 0x0000, 0x8108, 0xa72a, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x662a, 0x8108, 0x0000, 0x0000, 0xc208, 0x872a, 0xc72a, 0xc72a, 0x872a, 0x8108, 0x0000, 0x0000, 0x8108, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc82a, 0x8108, 0x0000, 0x0000, 0x8108, 0xc82a, 0x092b, 0x092b, 0xc82a, 0xe208, 0x0000, 0x0000, 0xa108, 0xa82a, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x662a, 0xa108, 0x0000, 0x0000, 0xa108, 0x662a, 0xc72a, 0xc72a, 0xc72a, 0x872a, 0x8419, 0x8419, 0x872a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0xc82a, 0xa519, 0xa519, 0xc82a, 0x092b, 0x082b, 0x092b, 0xa72a, 0xa208, 0x0000, 0x0000, 0xc208, 0xc82a, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xa72a, 0x0211, 0x0000, 0x0000, 0x4100, 0x4622, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x082b, 0x092b, 0x6722, 0x6100, 0x0000, 0x0000, 0x2311, 0xe82a, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x4311, 0x0000, 0x0000, 0x0000, 0x0522, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x082b, 0x092b, 0x2622, 0x0000, 0x0000, 0x0000, 0x8411, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc419, 0x0000, 0x2000, 0x0000, 0x8419, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0xa519, 0x0000, 0x2000, 0x0000, 0xe619, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x2622, 0x2000, 0x0000, 0x0000, 0xe208, 0xa72a, 0xc72a, 0xc82a, 0xc82a, 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0xc82a, 0xe308, 0x0000, 0x0000, 0x2000, 0x6722, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0x872a, 0xc208, 0x0000, 0x0000, 0x2000, 0x2622, 0xc82a, 0xc72a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x6722, 0x2000, 0x0000, 0x0000, 0xe208, 0xe82a, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc72a, 0xc82a, 0x8419, 0x0000, 0x2000, 0x0000, 0x8419, 0xc72a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x082b, 0xa419, 0x0000, 0x2000, 0x0000, 0xa519, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc82a, 0xc82a, 0xc82a, 0xc82a, 0xc82a, 0xc82a, 0xc72a, 0xc82a, 0x2622, 0x4000, 0x0000, 0x0000, 0x4000, 0x872a, 0xe82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0xa82a, 0x4100, 0x0000, 0x0000, 0x4100, 0x6722, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xc82a, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc72a, 0xc72a, 0x2311, 0x0000, 0x0000, 0x0000, 0x6419, 0xc72a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x8419, 0x0000, 0x0000, 0x0000, 0x4311, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc82a, 0xe82a, 0x0522, 0x4000, 0x0000, 0x0000, 0x2000, 0x4622, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x8722, 0x2000, 0x0000, 0x0000, 0x4000, 0x4622, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc82a, 0xc82a, 0x2311, 0x0000, 0x0000, 0x0000, 0xa108, 0xc72a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0xe82a, 0xa208, 0x0000, 0x0000, 0x0000, 0x4311, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x6622, 0x6108, 0x0000, 0x0000, 0x0000, 0x2311, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x2311, 0x0000, 0x0000, 0x0000, 0x8108, 0xa82a, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc82a, 0xe82a, 0xc519, 0x0000, 0x0000, 0x0000, 0x0000, 0x8419, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x4411, 0x0000, 0x0000, 0x0000, 0x0000, 0xe519, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x2311, 0x0000, 0x0000, 0x0000, 0x0000, 0x8419, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x6411, 0x0000, 0x0000, 0x0000, 0x0000, 0x4411, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe208, 0x0000, 0x0000, 0x0000, 0x0000, 0x2311, 0xc82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0xa72a, 0x8419, 0xe208, 0xe208, 0xa419, 0xa72a, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0xe82a, 0x2311, 0x0000, 0x0000, 0x0000, 0x0000, 0x0309, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc82a, 0xc208, 0x0000, 0x0000, 0x0000, 0x0000, 0xa108, 0x6622, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0xe82a, 0x082b, 0x0622, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0622, 0x092b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x6722, 0xa208, 0x0000, 0x0000, 0x0000, 0x0000, 0xc208, 0xe92a, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc82a, 0xe208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6411, 0x872a, 0x082b, 0x082b, 0x082b, 0x082b, 0x4622, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x6722, 0x092b, 0x092b, 0x092b, 0x092b, 0xa72a, 0x8411, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe308, 0xe92a, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, + 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x2311, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4000, 0x8419, 0x4622, 0xa72a, 0x082b, 0x0311, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0311, 0x092b, 0xc82a, 0x6722, 0x8419, 0x4000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x4411, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, + 0x0000, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xc519, 0x8108, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0xe208, 0x8419, 0x6100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6100, 0xa419, 0xe208, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x8108, 0xe519, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x0000, + 0x0000, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0xe82a, 0x082b, 0x6722, 0x2311, 0x4000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x4000, 0x4311, 0x8722, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x0000, + 0x0000, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0xe82a, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0xe82a, 0x082b, 0x082b, 0x2622, 0x2311, 0x4000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x4100, 0x4311, 0x2622, 0x292b, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x0000, + 0x0000, 0x0000, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0xe82a, 0x082b, 0x082b, 0x082b, 0x4622, 0xa419, 0xe208, 0x4000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4000, 0xe208, 0xa519, 0x4722, 0x292b, 0x292b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, + 0x0000, 0x0000, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0xe82a, 0x092b, 0x092b, 0x092b, 0xc82a, 0x4622, 0xe519, 0x8411, 0x2311, 0xc208, 0xa108, 0x8108, 0x8108, 0xa108, 0xc208, 0x2311, 0x8411, 0xe619, 0x6722, 0xc82a, 0x292b, 0x292b, 0x292b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0xe82a, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0xe82a, 0xc82a, 0xa82a, 0xa72a, 0xa72a, 0xa82a, 0xc82a, 0xe82a, 0x092b, 0x292b, 0x292b, 0x292b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x082b, 0x082b, 0x082b, 0x082b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x4a2b, 0x4a2b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x092b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x292b, 0x2a2b, 0x2a2b, 0x2a2b, 0x4a2b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Midnight_Blue_Back_64x64.c b/Firmware/Images/Image_Midnight_Blue_Back_64x64.c new file mode 100644 index 0000000..70afd2c --- /dev/null +++ b/Firmware/Images/Image_Midnight_Blue_Back_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Midnight_Blue_Back_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0379, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa491, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0379, 0x0379, 0x0379, 0x0379, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa491, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe378, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa499, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe378, 0xe378, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe370, 0xe378, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2379, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xe370, 0xe378, 0xe378, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xe378, 0xe378, 0xe378, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2379, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0xe378, 0xe378, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2379, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa491, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x0000, 0x0000, + 0x0000, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2379, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x6489, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x0000, + 0x0000, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2379, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x8491, 0x6481, 0x0361, 0x6481, 0xa491, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x0000, + 0x0000, 0x0379, 0x0379, 0x0379, 0x0379, 0x0379, 0x2379, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x8491, 0x4379, 0x6128, 0x2008, 0x4018, 0x6479, 0xa491, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x0000, + 0x0379, 0x0379, 0x0379, 0x0379, 0x2379, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0xe258, 0xa499, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86c2, + 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0xa491, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, + 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x2481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, + 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2381, 0x2481, 0x2481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0xa499, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, + 0x2481, 0x2481, 0x2481, 0x2481, 0x2481, 0x2481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4479, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, + 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4479, 0x4118, 0x0000, 0x0000, 0x0000, 0x0008, 0x6120, 0x2008, 0x0000, 0x0000, 0xe250, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, + 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4479, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe258, 0x2361, 0x0000, 0x0000, 0x0000, 0xe250, 0xa599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, + 0x4481, 0x4481, 0x4481, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4479, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xc248, 0xa491, 0x0361, 0x0008, 0x0000, 0x0000, 0xe250, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, + 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4479, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0x8491, 0xa491, 0x0361, 0x0008, 0x0000, 0x0000, 0xe250, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, + 0x4489, 0x4489, 0x4489, 0x4489, 0x4489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0x8491, 0x8491, 0xa491, 0x0361, 0x0008, 0x0000, 0x0000, 0xe250, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe599, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, + 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0x8491, 0x8491, 0xa491, 0xa499, 0x2361, 0x0008, 0x0000, 0x0000, 0x6120, 0xe250, 0x2369, 0x4371, 0x8489, 0xc599, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, + 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0x8491, 0x8491, 0xa491, 0xa491, 0xa499, 0x0361, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6118, 0xa238, 0x0259, 0x6371, 0xc599, 0x05a2, 0x05aa, 0x05a2, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, + 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x6489, 0x8491, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0xa491, 0x8491, 0xa491, 0xa499, 0xa491, 0xa599, 0x4379, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x8130, 0x0251, 0xa481, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, + 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6489, 0x6491, 0x6491, 0x8491, 0x6489, 0x8491, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe250, 0xa491, 0x8491, 0xa491, 0xa499, 0xa499, 0xa599, 0xa599, 0xa499, 0x0361, 0x8130, 0x6120, 0x4010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0000, 0x0000, 0x0000, 0x4018, 0xe248, 0xa481, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, + 0x6491, 0x6491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8489, 0x8491, 0x4379, 0x4120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe258, 0xa491, 0xa491, 0xa499, 0xa499, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xa491, 0x8489, 0x8481, 0x6371, 0x2361, 0xc248, 0x8128, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4018, 0xe248, 0xe599, 0x25aa, 0x25aa, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, + 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x4379, 0x6120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe258, 0xa491, 0xa491, 0xa499, 0xa499, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xc491, 0x8481, 0x2361, 0x8130, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6120, 0x8479, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, + 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x4379, 0x6120, 0x0000, 0x0000, 0x0000, 0x0000, 0xe258, 0xa491, 0xa499, 0xa491, 0xa499, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0xe599, 0xa481, 0xe248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x0251, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, + 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0xc240, 0x0000, 0x0000, 0x0000, 0x0000, 0x0359, 0xa499, 0xa499, 0xa499, 0xa499, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05a2, 0xc489, 0xc240, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa238, 0x26b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, + 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0x8491, 0xa491, 0xa491, 0xa138, 0x0000, 0x0000, 0x0000, 0x0000, 0x4371, 0xa499, 0xa499, 0xa599, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x05aa, 0x8481, 0x4018, 0x0000, 0x0000, 0x0000, 0x0000, 0x8130, 0x25aa, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, + 0xa491, 0xa491, 0xa491, 0xa491, 0xa491, 0xa491, 0x8491, 0xa491, 0x4371, 0x2010, 0x0000, 0x0000, 0x0000, 0x2008, 0x4371, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x05a2, 0xa130, 0x0000, 0x0000, 0x0000, 0x0000, 0xa130, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, + 0xa491, 0xa491, 0xa499, 0xa499, 0xa499, 0xa499, 0xa499, 0xa491, 0xa499, 0x2369, 0x2010, 0x0000, 0x0000, 0x0000, 0x0008, 0x4379, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x46b2, 0xe248, 0x0000, 0x0000, 0x0000, 0x0000, 0xe248, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, + 0xa499, 0xa499, 0xa499, 0xa499, 0xa499, 0xa499, 0xa499, 0xa499, 0xa599, 0xa599, 0x2369, 0x2010, 0x0000, 0x0000, 0x0000, 0x0008, 0x6479, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe599, 0xe599, 0xe599, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x26b2, 0x26b2, 0x46b2, 0xe240, 0x0000, 0x0000, 0x0000, 0x0000, 0x4369, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, + 0xa599, 0xa599, 0xa599, 0xa599, 0xa599, 0xa599, 0xa599, 0xa599, 0xa599, 0xa499, 0xc599, 0x4369, 0x2010, 0x0000, 0x0000, 0x0000, 0x2008, 0x6479, 0xc5a1, 0xc599, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x6479, 0xe248, 0xa138, 0x8130, 0x8128, 0x8128, 0xa130, 0xa130, 0xc240, 0x0359, 0x4369, 0x8481, 0xe591, 0x05a2, 0x25aa, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0xc238, 0x0000, 0x0000, 0x0000, 0x4010, 0x05a2, 0x66ba, 0x66ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xc7ca, + 0xa599, 0xa599, 0xa599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0x4369, 0x2010, 0x0000, 0x0000, 0x0000, 0x2008, 0x6479, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xa481, 0x4010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6120, 0xe248, 0x8479, 0xe599, 0x46b2, 0x46b2, 0x46b2, 0x25aa, 0x4018, 0x0000, 0x0000, 0x0000, 0xc238, 0x66ba, 0x66ba, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, + 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0x4371, 0x2010, 0x0000, 0x0000, 0x0000, 0x2008, 0x6479, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x4369, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4010, 0x0251, 0xc489, 0x46b2, 0x66ba, 0xc489, 0x0000, 0x0000, 0x0000, 0x2008, 0xa479, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xc7ca, 0xc7ca, + 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc599, 0xc5a1, 0x4371, 0x2010, 0x0000, 0x0000, 0x0000, 0x2008, 0x6479, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x4369, 0x2008, 0x0000, 0x0000, 0x2008, 0x4018, 0x6118, 0x4018, 0x4018, 0x4010, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0000, 0x0000, 0x0000, 0xe248, 0xe591, 0x66ba, 0x0251, 0x0000, 0x0000, 0x0000, 0xc238, 0x66ba, 0x86ba, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, + 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc599, 0xc5a1, 0xc5a1, 0xc5a1, 0xc5a1, 0xc5a1, 0xc5a1, 0xe5a1, 0xc599, 0xe5a1, 0x6371, 0x2010, 0x0000, 0x0000, 0x0000, 0x2010, 0x6479, 0xe5a1, 0xe5a1, 0x05aa, 0x4369, 0x2008, 0x0000, 0x0000, 0xe248, 0xa489, 0xc491, 0xa489, 0xa489, 0xa481, 0x6371, 0x4361, 0x0251, 0xa138, 0x6118, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4010, 0x6369, 0x059a, 0x2010, 0x0000, 0x0000, 0x2008, 0xc481, 0x86c2, 0x86ba, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, + 0xc5a1, 0xc5a1, 0xc5a1, 0xc5a1, 0xc5a1, 0xc5a1, 0xc5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x6371, 0x2010, 0x0000, 0x0000, 0x0000, 0x2010, 0x6479, 0x05aa, 0x05a2, 0x4369, 0x2008, 0x0000, 0x0000, 0x2361, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0xc591, 0x6371, 0x0249, 0x6120, 0x0000, 0x0000, 0x0008, 0x0000, 0x0000, 0xe240, 0xe240, 0x0000, 0x0000, 0x0000, 0x0249, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, + 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x6479, 0x2010, 0x0000, 0x0000, 0x0000, 0x2010, 0x6479, 0x05aa, 0x4369, 0x2008, 0x0000, 0x0000, 0x2359, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0xe599, 0x4361, 0x6120, 0x0000, 0x0000, 0x0000, 0x0000, 0x4018, 0x0000, 0x0000, 0x0000, 0x8128, 0x45aa, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, + 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x6479, 0x2010, 0x0000, 0x0000, 0x0000, 0x2010, 0x8481, 0x6479, 0x0000, 0x0000, 0x0000, 0x2359, 0x25aa, 0x25b2, 0x25b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x059a, 0x2359, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa479, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, + 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05a2, 0x05aa, 0x05a2, 0x05aa, 0x8479, 0x2010, 0x0000, 0x0000, 0x0000, 0x4118, 0xc240, 0x2008, 0x0000, 0x0000, 0x2359, 0x25aa, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0xa479, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2351, 0xa6c2, 0xa6c2, 0xa7c2, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, + 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05a2, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x8479, 0x2010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2359, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0xe591, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc238, 0x86ba, 0xa7ca, 0xa7c2, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, + 0xe5a1, 0xe5a1, 0xe5a1, 0xe5a1, 0x05a2, 0x05a2, 0x05a2, 0x05a2, 0x05a2, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x8479, 0x2010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2361, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0xc489, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6120, 0x25a2, 0xa7ca, 0xa6c2, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, + 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x05aa, 0x25aa, 0x8481, 0x2010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2361, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x6361, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0xe589, 0xc7ca, 0xc7c2, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, + 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x8481, 0x2010, 0x0000, 0x0000, 0x0000, 0x0000, 0x2361, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x66b2, 0x8128, 0x0000, 0x0000, 0x0000, 0x0000, 0xa479, 0xc7ca, 0xa7c2, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7d2, 0xe7d2, + 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x25aa, 0x26b2, 0x8479, 0x2010, 0x0000, 0x0000, 0x0000, 0x4361, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xc481, 0x0000, 0x0000, 0x0000, 0x0000, 0x8369, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, + 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x05aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x25b2, 0x25b2, 0x26b2, 0x26b2, 0x25aa, 0x46b2, 0x8479, 0x4010, 0x0000, 0x0008, 0xc489, 0x46b2, 0x46b2, 0x46ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0x66aa, 0x6120, 0x0000, 0x0000, 0x0000, 0x6361, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, + 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x25b2, 0x26b2, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0xe591, 0x2359, 0xa481, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0x4361, 0x0000, 0x2008, 0x0000, 0x4359, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, + 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x25b2, 0x25b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xe489, 0x0000, 0x2008, 0x0000, 0x2251, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, + 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25aa, 0x25b2, 0x25b2, 0x25b2, 0x25b2, 0x25b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xc7ca, 0x45aa, 0x4010, 0x0000, 0x0000, 0x0249, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, + 0x0000, 0x25b2, 0x25b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xa6c2, 0x6369, 0x4010, 0x6118, 0xe489, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x0000, + 0x0000, 0x26b2, 0x26b2, 0x26b2, 0x26b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7c2, 0x0592, 0x45a2, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x0000, + 0x0000, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x0000, + 0x0000, 0x0000, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, + 0x0000, 0x0000, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x46b2, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7ca, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x66ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86ba, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x07d3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0x86c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa6c2, 0xa7c2, 0xa7ca, 0xa7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xc7ca, 0xe7ca, 0xe7ca, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0xe7d2, 0x07d3, 0x07d3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Music_64x64.c b/Firmware/Images/Image_Music_64x64.c new file mode 100644 index 0000000..984bc00 --- /dev/null +++ b/Firmware/Images/Image_Music_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Music_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8008, 0x201a, 0x402b, 0x603c, 0x604d, 0xc04d, 0x2056, 0x805e, 0x805e, 0x2056, 0xc04d, 0x604d, 0x403c, 0x402b, 0x201a, 0x8008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6011, 0xa033, 0x804d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x804d, 0xa033, 0x6011, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6000, 0x002b, 0x804d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x804d, 0x002b, 0x4000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6000, 0x402b, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x2056, 0x402b, 0x6000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6022, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x2056, 0xe02a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe008, 0x2045, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0045, 0xe008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x001a, 0x4056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xe25d, 0xe25d, 0xa25d, 0x235d, 0x235d, 0x235d, 0x235d, 0x235d, 0x235d, 0x235d, 0x205e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x4056, 0x401a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc033, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x444c, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa033, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x403c, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x244c, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x403c, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xa044, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x244c, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa044, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x203c, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x244c, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x403c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc033, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x6852, 0x6852, 0x6852, 0x6852, 0x6852, 0x634c, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa033, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x201a, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x4022, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe008, 0x4056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x4056, 0xe008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2045, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0045, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8022, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x8022, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x6000, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x2056, 0x6000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x602b, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x402b, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x6000, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x2056, 0x4000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x002b, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x002b, 0x0000, 0x0000, + 0x0000, 0x0000, 0x804d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x804d, 0x0000, 0x0000, + 0x0000, 0x6011, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x4011, 0x0000, + 0x0000, 0xa033, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0a63, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa34c, 0x0654, 0x0654, 0x0654, 0x0654, 0x0654, 0x0654, 0x0654, 0x0654, 0x0654, 0x0654, 0xc653, 0x2753, 0x2753, 0x2753, 0x2753, 0x475b, 0x675b, 0x675b, 0x675b, 0x675b, 0x675b, 0xa65b, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa033, 0x0000, + 0x0000, 0x804d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x015e, 0x045d, 0xe564, 0xea62, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa962, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0xc045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x604d, 0x0000, + 0x8008, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x635d, 0x8863, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa962, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0xc045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x8000, + 0x201a, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0x4664, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa962, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0xc045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x201a, + 0x402b, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x0764, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa962, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0xa04d, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x402b, + 0x603c, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xc564, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa962, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0xc045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x403c, + 0x404d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x605e, 0xea62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0x4852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xc045, 0x805e, 0xa05e, 0xa05e, 0xa05e, 0x404d, + 0xc04d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xe464, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa04d, 0x805e, 0xa05e, 0xa05e, 0xc04d, + 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xe763, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0xa852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa04d, 0x805e, 0xa05e, 0x2056, + 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x8863, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x4852, 0xc553, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa04d, 0x805e, 0x8056, + 0x805e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xc763, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x6852, 0x6145, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa04d, 0x6056, + 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xc564, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xa95a, 0x634c, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa045, + 0xc04d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x605e, 0x0963, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xea62, 0xc34c, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, + 0x404d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x825d, 0x0963, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x685b, 0x224d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6045, + 0x403c, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x2156, 0x2554, 0x685b, 0x2963, 0x685b, 0xe65b, 0xc34c, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x2045, + 0x402b, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0654, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6034, + 0x201a, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x4145, 0xa44c, 0x4554, 0x685b, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa34c, 0xa553, 0x4653, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x2023, + 0x8008, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x4145, 0xe65b, 0xea62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x634c, 0xa852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xe008, + 0x0000, 0x804d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xe34c, 0x0963, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6653, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6045, 0x0000, + 0x0000, 0xa033, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x8045, 0x8045, 0x8045, 0x8045, 0x024d, 0xea62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6653, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa03c, 0x0000, + 0x0000, 0x6011, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x8045, 0x8045, 0x6145, 0x2963, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x024d, 0x8045, 0x8045, 0x8045, 0x8045, 0x634c, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x001a, 0x0000, + 0x0000, 0x0000, 0x804d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x8045, 0x6454, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x224d, 0x8045, 0x8045, 0x8045, 0x8045, 0xa852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x6852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0000, 0x0000, + 0x0000, 0x0000, 0x002b, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x6056, 0x685b, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x6145, 0x8045, 0x8045, 0x8045, 0x0245, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8852, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0034, 0x0000, 0x0000, + 0x0000, 0x0000, 0x4000, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xea62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x685b, 0x8045, 0x8045, 0x8045, 0x8045, 0x044c, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x2753, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8008, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x402b, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x6454, 0x8045, 0x8045, 0x8045, 0x8045, 0xe54b, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0xc34c, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x603c, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x6000, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x2963, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x485b, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x834c, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x2753, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa008, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8022, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x8564, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x0963, 0x2245, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6045, 0x6852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0xa852, 0x6145, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa02b, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0045, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x605e, 0x4963, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0xca62, 0x4863, 0x224d, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x444c, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0x4852, 0xc752, 0x4145, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6045, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe008, 0x4056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x415e, 0xc75b, 0xca62, 0xca62, 0xca62, 0xca62, 0x2963, 0x4454, 0x6145, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x644c, 0x8852, 0x4852, 0x4852, 0x4852, 0x4852, 0x8852, 0x044c, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6011, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x201a, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0x814d, 0xe34c, 0xc34c, 0x2245, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xe24c, 0x244c, 0x444c, 0x0245, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x402b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa033, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa03c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x203c, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x2045, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xa044, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x4045, 0x4000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x003c, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x2045, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa033, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa03c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x001a, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x402b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe008, 0x0045, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x6045, 0x6011, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6022, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0xe033, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6000, 0x402b, 0x2056, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x603c, 0xa008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4000, 0x002b, 0x804d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x8045, 0x0034, 0x8008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4011, 0xa033, 0x604d, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0xa05e, 0x805e, 0xa045, 0x8045, 0x8045, 0x8045, 0x8045, 0xa03c, 0x201a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x201a, 0x402b, 0x403c, 0x4045, 0xc04d, 0x2056, 0x805e, 0x805e, 0x2056, 0xc04d, 0x4045, 0x603c, 0x6034, 0x2023, 0x0009, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Olive_Sage_Diskette_64x64.c b/Firmware/Images/Image_Olive_Sage_Diskette_64x64.c new file mode 100644 index 0000000..cb54dda --- /dev/null +++ b/Firmware/Images/Image_Olive_Sage_Diskette_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Olive_Sage_Diskette_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xae24, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xad24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8d24, 0x8d24, 0xad24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xef24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8d24, 0x8d24, 0x8d24, 0xad24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xef24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8d24, 0x8d24, 0x8d24, 0xad24, 0x8e24, 0xad24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xef24, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xef24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x702d, 0x702d, 0x502d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0xad24, 0xae24, 0x6d24, 0xeb1b, 0xeb1b, 0xeb1b, 0xec1b, 0x0c1c, 0x0c1c, 0x0c1c, 0x0c1c, 0x0c24, 0x0c24, 0x0c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x4c24, 0x4c24, 0x4c24, 0x4c24, 0x4d24, 0x4d24, 0x4d24, 0x6d24, 0x6d24, 0x6d24, 0x6d24, 0x6d24, 0x6d24, 0x8d24, 0xce24, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0xae24, 0x8a1b, 0xa509, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xa200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xc200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xc200, 0xc200, 0xc200, 0x4409, 0x8712, 0x0c1c, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0x0000, 0x0000, + 0x0000, 0x0000, 0x8d24, 0x8d24, 0xad24, 0x8d24, 0xae24, 0x8a1b, 0x6100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4100, 0xe812, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0x0000, 0x0000, + 0x0000, 0xad24, 0xad24, 0xad24, 0x8d24, 0xae24, 0x6d24, 0xa409, 0x0000, 0xa200, 0x0612, 0x6712, 0x6712, 0x6712, 0x6712, 0x6712, 0x6712, 0x6712, 0xc200, 0x0000, 0x8100, 0x8712, 0x6712, 0x8712, 0x8712, 0x8712, 0x8712, 0x8712, 0x8712, 0x8712, 0x8712, 0xa712, 0xa712, 0xa712, 0xa812, 0xa812, 0xa812, 0xa712, 0xa812, 0xa812, 0xc509, 0x4000, 0x0000, 0x8409, 0xa100, 0x0000, 0x0000, 0xa812, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0x0000, + 0x0000, 0xae24, 0xae24, 0xae24, 0xad24, 0xae24, 0xeb1b, 0xe200, 0x0000, 0x0612, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0x8409, 0x0000, 0x2309, 0xee24, 0xee24, 0xef24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0xcb1b, 0x6100, 0x0000, 0x2c24, 0x0c1c, 0xc200, 0x0000, 0x0000, 0xa812, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0x0000, + 0x0000, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xeb1b, 0xc200, 0x0000, 0x6712, 0xae24, 0x8d24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xad24, 0x6409, 0x0000, 0x0309, 0xce24, 0xae24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xef24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x2f2d, 0xee24, 0xce24, 0x4f2d, 0x2f2d, 0x6a1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x6d24, 0xe200, 0x0000, 0x0000, 0x8712, 0x902d, 0x702d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0x0000, + 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xeb1b, 0xc200, 0x0000, 0x6712, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0x6409, 0x0000, 0x0309, 0xee24, 0xce24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x8d24, 0x2309, 0x8409, 0x6d24, 0x502d, 0x6a1b, 0x6100, 0x0000, 0x4c24, 0x502d, 0x702d, 0x8d24, 0xc200, 0x0000, 0x0000, 0x8712, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xec1b, 0xc200, 0x0000, 0x6712, 0xce24, 0xae24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xce24, 0x6409, 0x0000, 0x0309, 0xee24, 0xce24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x0c24, 0x0000, 0x4000, 0x6a1b, 0x502d, 0x6a1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x502d, 0x702d, 0x8d24, 0xe200, 0x0000, 0x0000, 0x8712, 0x902d, 0x902d, 0x902d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xce24, 0x0c1c, 0xc200, 0x0000, 0x6712, 0xce24, 0xae24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xce24, 0x6409, 0x0000, 0x0309, 0xef24, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2c24, 0x0000, 0x6100, 0x4a1b, 0x502d, 0x6a1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x702d, 0x702d, 0x902d, 0x8d24, 0xe200, 0x0000, 0x0000, 0x8712, 0xb02d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xce24, 0xce24, 0xce24, 0xce24, 0xae24, 0xce24, 0x0c1c, 0xc200, 0x0000, 0x6712, 0xce24, 0xae24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xce24, 0x6409, 0x0000, 0x2309, 0xef24, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2c24, 0x0000, 0x6100, 0x6a1b, 0x502d, 0x6a1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x8d24, 0xe200, 0x0000, 0x0000, 0xa812, 0xb12d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0x0c1c, 0xc200, 0x0000, 0x6712, 0xce24, 0xae24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xce24, 0x6409, 0x0000, 0x2309, 0x0f25, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x2c24, 0x0000, 0x6100, 0x4a1b, 0x502d, 0x6a1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x8d24, 0xe200, 0x0000, 0x0000, 0xa812, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0x0c1c, 0xc200, 0x0000, 0x6712, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xce24, 0x6409, 0x0000, 0x2309, 0x0f25, 0xee24, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x6d24, 0x2000, 0xc200, 0x0c1c, 0x502d, 0x6a1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x8d24, 0xe200, 0x0000, 0x0000, 0x291b, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0x0c24, 0xc200, 0x0000, 0x8712, 0xee24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xce24, 0x6409, 0x0000, 0x2309, 0x0f25, 0xce24, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x8d24, 0x6d24, 0x4f2d, 0x502d, 0x8a1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x8d24, 0xe200, 0x0000, 0x6100, 0x4c24, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0x0c24, 0xc200, 0x0000, 0x8712, 0xee24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xce24, 0x6409, 0x0000, 0x2309, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0xab1b, 0x6100, 0x0000, 0x4c24, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0x2c24, 0x8100, 0x0000, 0x8712, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, + 0xce24, 0xce24, 0xce24, 0xee24, 0xce24, 0xee24, 0x0c24, 0xc200, 0x0000, 0x8712, 0xee24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xef24, 0xee24, 0x6409, 0x0000, 0xe200, 0x0c1c, 0xeb1b, 0x0c24, 0x0c24, 0x0c24, 0x0c24, 0x0c24, 0x0c24, 0x0c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x2c24, 0x4c24, 0xc812, 0x6100, 0x0000, 0x4c24, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x4612, 0x0000, 0x6409, 0x0f2d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, + 0xee24, 0xee24, 0xee24, 0xee24, 0xce24, 0xee24, 0x2c24, 0xc200, 0x0000, 0x8712, 0xee24, 0xce24, 0xee24, 0xee24, 0xef24, 0xef24, 0x0f25, 0xef24, 0x4712, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4000, 0xad24, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0x902d, 0xb02d, 0xc812, 0x0000, 0x0309, 0xee24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, + 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0x2c24, 0xc200, 0x0000, 0x8712, 0xee24, 0xce24, 0xef24, 0xef24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x6d24, 0x4309, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0x6100, 0xc200, 0x291b, 0x502d, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0x902d, 0xb12d, 0xe812, 0x0000, 0xe200, 0xce24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, + 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0x2c24, 0xc200, 0x0000, 0x8712, 0xef24, 0xce24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0xce24, 0x8a1b, 0x4a1b, 0x4a1b, 0x4a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x6a1b, 0x8a1b, 0x8a1b, 0x8a1b, 0x8a1b, 0x8a1b, 0x8a1b, 0x4d24, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0x902d, 0xb12d, 0xe812, 0x0000, 0xe208, 0xce24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, + 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0x2c24, 0xc200, 0x0000, 0x8712, 0x0f25, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0x902d, 0xb12d, 0xe812, 0x0000, 0xe208, 0xce24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, + 0xee24, 0xee24, 0xef24, 0xef24, 0xee24, 0xef24, 0x2c24, 0xc200, 0x0000, 0x8712, 0x0f25, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x0f2d, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x2f25, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0x902d, 0xb12d, 0xe812, 0x0000, 0xe208, 0xce24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, + 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0xee24, 0x0f25, 0x2c24, 0xc200, 0x0000, 0x8712, 0x0f25, 0xee24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0x902d, 0xb12d, 0xe812, 0x0000, 0xe208, 0xce24, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, + 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0xef24, 0x0f25, 0x2c24, 0xc200, 0x0000, 0x8712, 0x0f25, 0xee24, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0x902d, 0xb12d, 0xe812, 0x0000, 0xe208, 0xce24, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, + 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x2c24, 0xc200, 0x0000, 0x8712, 0x0f25, 0xee24, 0x0f2d, 0x0f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0x902d, 0xb12d, 0xe812, 0x0000, 0xe208, 0xee24, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, + 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x4c24, 0xc200, 0x0000, 0x8712, 0x0f2d, 0xef24, 0x0f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0x902d, 0xd12d, 0xe812, 0x0000, 0xe208, 0xee24, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, + 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f2d, 0x0f2d, 0x4c24, 0xc200, 0x0000, 0x8712, 0x2f2d, 0x0f25, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0x902d, 0xd12d, 0xe812, 0x0000, 0xe208, 0xee24, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, + 0x0f2d, 0x0f2d, 0x0f2d, 0x0f2d, 0x0f2d, 0x0f2d, 0x4c24, 0xe200, 0x0000, 0xa712, 0x2f2d, 0x0f25, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb02d, 0xd12d, 0xe812, 0x0000, 0xe308, 0xee24, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, + 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x0f2d, 0x2f2d, 0x4c24, 0xe200, 0x0000, 0xa712, 0x2f2d, 0x0f25, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb02d, 0xd12d, 0xe812, 0x0000, 0xe308, 0xee24, 0xf12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, + 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4d24, 0xe200, 0x0000, 0xa712, 0x2f2d, 0x0f25, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xb02d, 0xd12d, 0xe812, 0x0000, 0x0309, 0xee24, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, + 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4d24, 0xe200, 0x0000, 0xa812, 0x2f2d, 0x0f25, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xb12d, 0xd12d, 0xe812, 0x0000, 0x0309, 0xee24, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, + 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x4d24, 0xe200, 0x0000, 0xa812, 0x2f2d, 0x0f2d, 0x2f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xb12d, 0xd12d, 0xe812, 0x0000, 0x0309, 0xee24, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0x122e, + 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x6d24, 0xe200, 0x0000, 0xa812, 0x4f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0xce24, 0x6d24, 0x6d24, 0x6d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0x8d24, 0xad24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xae24, 0xce24, 0xce24, 0xce24, 0x2f2d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xb12d, 0xd12d, 0xe812, 0x0000, 0x0309, 0xee24, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0x122e, + 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x2f2d, 0x6d24, 0xe200, 0x0000, 0xa812, 0x4f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0xcb1b, 0x6409, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xa409, 0x0c24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xb12d, 0xd12d, 0xe812, 0x0000, 0x0309, 0xee24, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0x122e, 0x122e, + 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x2f2d, 0x4f2d, 0x6d24, 0xe200, 0x0000, 0xa812, 0x4f2d, 0x2f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0xee24, 0x6100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6100, 0x502d, 0xd12d, 0xd12d, 0xd12d, 0xb12d, 0xd12d, 0xe912, 0x0000, 0x0309, 0xee24, 0xf12d, 0xf12d, 0xf12d, 0x122e, 0x122e, 0x122e, + 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x6d24, 0xe200, 0x0000, 0xa812, 0x4f2d, 0x2f2d, 0x502d, 0x4f2d, 0x502d, 0xeb1b, 0x0000, 0x0000, 0xe609, 0xc812, 0xa812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xc812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0x0612, 0x2000, 0x2000, 0x4d24, 0xd12d, 0xd12d, 0xd12d, 0xb12d, 0xd12d, 0x0913, 0x0000, 0x0309, 0xee24, 0xf12d, 0xf12d, 0xf22d, 0x122e, 0x122e, 0x122e, + 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x4f2d, 0x6d24, 0xe200, 0x0000, 0xa812, 0x502d, 0x2f2d, 0x502d, 0x4f2d, 0x502d, 0xcb1b, 0x0000, 0x0000, 0x4c24, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0x8d24, 0x0000, 0x0000, 0x2c24, 0xd12d, 0xd12d, 0xd12d, 0xb12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0xef24, 0xf12d, 0xf12d, 0x122e, 0x122e, 0x122e, 0x122e, + 0x502d, 0x502d, 0x502d, 0x502d, 0x4f2d, 0x502d, 0x6d24, 0xe200, 0x0000, 0xa812, 0x502d, 0x2f2d, 0x502d, 0x502d, 0x702d, 0xeb1b, 0x0000, 0x0000, 0xcb1b, 0x4f2d, 0x4f2d, 0x4f2d, 0x502d, 0x502d, 0x502d, 0x502d, 0x502d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x0c24, 0x0000, 0x0000, 0x2c24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0xef24, 0xf12d, 0xf12d, 0x122e, 0x122e, 0x122e, 0x122e, + 0x502d, 0x502d, 0x502d, 0x502d, 0x4f2d, 0x502d, 0x8d24, 0xe200, 0x0000, 0xa812, 0x702d, 0x4f2d, 0x702d, 0x502d, 0x702d, 0xeb1b, 0x0000, 0x0000, 0xeb1b, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x2c24, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0x0f25, 0xf22d, 0xf12d, 0x122e, 0x122e, 0x122e, 0x122e, + 0x502d, 0x502d, 0x502d, 0x702d, 0x502d, 0x702d, 0x8d24, 0xe200, 0x0000, 0xc812, 0x702d, 0x4f2d, 0x702d, 0x702d, 0x702d, 0xeb1b, 0x0000, 0x0000, 0xeb1b, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x2c24, 0xd12d, 0xd12d, 0xf12d, 0xd12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0x0f25, 0x122e, 0xf12d, 0x122e, 0x122e, 0x122e, 0x122e, + 0x702d, 0x702d, 0x702d, 0x702d, 0x502d, 0x702d, 0x8d24, 0xe200, 0x0000, 0xc812, 0x702d, 0x4f2d, 0x702d, 0x702d, 0x702d, 0xeb1b, 0x0000, 0x0000, 0xeb1b, 0x702d, 0x702d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xb12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x2c24, 0xd12d, 0xd12d, 0xf12d, 0xd12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0x0f25, 0x122e, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, + 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x8d24, 0xe200, 0x0000, 0xc812, 0x702d, 0x502d, 0x702d, 0x702d, 0x702d, 0xeb1b, 0x0000, 0x0000, 0xeb1b, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x2c24, 0xf12d, 0xd12d, 0xf12d, 0xd12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0x0f25, 0x122e, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, + 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x8d24, 0xe200, 0x0000, 0xc812, 0x702d, 0x502d, 0x702d, 0x702d, 0x702d, 0xeb1b, 0x0000, 0x0000, 0xeb1b, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x4c24, 0xf12d, 0xf12d, 0xf12d, 0xd12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0x0f25, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x322e, + 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x8d24, 0xe200, 0x0000, 0xc812, 0x702d, 0x502d, 0x702d, 0x702d, 0x902d, 0xeb1b, 0x0000, 0x0000, 0x0c1c, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x4c24, 0xf12d, 0xf12d, 0xf12d, 0xd12d, 0xf12d, 0x0913, 0x0000, 0x0309, 0x0f25, 0x122e, 0x122e, 0x122e, 0x122e, 0x322e, 0x3236, + 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x702d, 0x8d24, 0xe200, 0x0000, 0xc812, 0x902d, 0x702d, 0x902d, 0x702d, 0x902d, 0x0c1c, 0x0000, 0x0000, 0x0c1c, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x4c24, 0xf12d, 0xf12d, 0xf12d, 0xd12d, 0xf22d, 0x0913, 0x0000, 0x0309, 0x0f25, 0x122e, 0x122e, 0x122e, 0x322e, 0x322e, 0x3236, + 0x902d, 0x902d, 0x902d, 0x902d, 0x702d, 0x902d, 0xad24, 0xe200, 0x0000, 0xc812, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0x0c1c, 0x0000, 0x0000, 0x0c1c, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0x4c24, 0x0000, 0x0000, 0x4c24, 0xf12d, 0xf12d, 0xf12d, 0xd12d, 0x122e, 0x091b, 0x0000, 0x0309, 0x0f25, 0x122e, 0x122e, 0x122e, 0x322e, 0x3236, 0x3236, + 0x902d, 0x902d, 0x902d, 0x902d, 0x702d, 0x902d, 0xae24, 0xe200, 0x0000, 0xc812, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0x0c1c, 0x0000, 0x0000, 0x0c1c, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0x4c24, 0x0000, 0x0000, 0x4c24, 0xf12d, 0xf12d, 0xf22d, 0xd12d, 0x122e, 0x091b, 0x0000, 0x0309, 0x0f25, 0x122e, 0x122e, 0x322e, 0x3236, 0x3236, 0x3236, + 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xae24, 0xe200, 0x0000, 0xc812, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0x0c1c, 0x0000, 0x0000, 0x0c1c, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0x4c24, 0x0000, 0x0000, 0x4c24, 0xf12d, 0xf12d, 0x122e, 0xd12d, 0x122e, 0x091b, 0x0000, 0x0309, 0x2f25, 0x122e, 0x122e, 0x3236, 0x3236, 0x3236, 0x3236, + 0x0000, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xae24, 0xe200, 0x0000, 0xe812, 0x902d, 0x4f2d, 0x702d, 0x702d, 0x702d, 0xeb1b, 0x0000, 0x0000, 0xeb1b, 0x902d, 0x702d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0xb02d, 0xb02d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xb12d, 0xd12d, 0x2c24, 0x0000, 0x0000, 0x2c24, 0xd12d, 0xd12d, 0xd12d, 0xb12d, 0xf12d, 0x291b, 0x0000, 0x0309, 0x2f25, 0x322e, 0x1236, 0x3236, 0x3236, 0x3236, 0x0000, + 0x0000, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0xae24, 0x0309, 0x0000, 0x6712, 0x902d, 0x902d, 0x902d, 0x902d, 0xb02d, 0x6d24, 0x0000, 0x0000, 0x6d24, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xae24, 0x0000, 0x0000, 0xce24, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x8712, 0x0000, 0x2309, 0x2f2d, 0x3236, 0x1236, 0x3236, 0x3236, 0x3236, 0x0000, + 0x0000, 0x902d, 0x902d, 0x902d, 0x902d, 0x902d, 0x502d, 0xe509, 0x0000, 0xc200, 0x6712, 0xe812, 0xc812, 0xc812, 0xe812, 0x0612, 0x0000, 0x0000, 0x0612, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe812, 0xe912, 0x0913, 0x0913, 0x0913, 0x0913, 0x0913, 0x0913, 0x2612, 0x0000, 0x0000, 0x2612, 0x091b, 0x091b, 0x091b, 0x291b, 0xa812, 0xe200, 0x0000, 0x2612, 0xd12d, 0x3236, 0x1236, 0x3236, 0x3236, 0x3236, 0x0000, + 0x0000, 0x0000, 0xb02d, 0xb02d, 0xb02d, 0x902d, 0xb02d, 0x2c24, 0x8100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa200, 0xae24, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, + 0x0000, 0x0000, 0xb12d, 0xb12d, 0xb12d, 0xb02d, 0xb02d, 0xb02d, 0x4c24, 0x0612, 0x0309, 0xe200, 0xe208, 0xe200, 0xe200, 0xe200, 0xc200, 0xc200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe200, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe308, 0xe308, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0xe200, 0xe200, 0x0309, 0x0309, 0x0309, 0x0309, 0x0309, 0x2309, 0x4612, 0xad24, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0x702d, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xce24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xee24, 0xef24, 0xef24, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x0f25, 0x2f25, 0x2f25, 0x2f2d, 0xd12d, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x322e, 0x3236, 0x3236, 0x1236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x1236, 0x1236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x322e, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x322e, 0x322e, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x322e, 0x322e, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xd12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf12d, 0xf22d, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x122e, 0x322e, 0x3236, 0x3236, 0x3236, 0x3236, 0x3236, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Rust_Orange_About1_64x64.c b/Firmware/Images/Image_Rust_Orange_About1_64x64.c new file mode 100644 index 0000000..90adebc --- /dev/null +++ b/Firmware/Images/Image_Rust_Orange_About1_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Rust_Orange_About1_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd73a, 0xd73a, 0xd73a, 0xd73a, 0xd73a, 0xd73a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb63a, 0x953a, 0x7432, 0x7432, 0x7432, 0x7432, 0x9532, 0xb63a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb742, 0xd742, 0xd742, 0xd742, 0x953a, 0x3232, 0xcf29, 0x6b19, 0x0811, 0xa610, 0x8408, 0x6308, 0x6308, 0x8408, 0xc610, 0x0811, 0x6b19, 0xcf21, 0x322a, 0xb632, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x0000, 0x0000, + 0x0000, 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xb742, 0xb742, 0xd742, 0xd742, 0x1132, 0x6c21, 0xc610, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0xc710, 0x8c19, 0x322a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x0000, 0x0000, + 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xb742, 0xd742, 0xd742, 0xf029, 0x0919, 0x4200, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x4200, 0x2911, 0x1122, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x0000, + 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xb742, 0xd742, 0xb742, 0xd742, 0x533a, 0x0919, 0x2100, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x6308, 0xa508, 0xc710, 0xe810, 0xe810, 0xc710, 0xa508, 0x6300, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x2100, 0x2911, 0x742a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x0000, + 0x0000, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xb742, 0xd742, 0xb742, 0xd742, 0xae29, 0x6308, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0xe810, 0x8d21, 0x112a, 0x5332, 0x7432, 0x963a, 0xb63a, 0xb63a, 0xb632, 0x9532, 0x532a, 0x112a, 0xad21, 0xe810, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x8408, 0xce21, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x0000, + 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xb742, 0x0919, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4208, 0x8c21, 0x3232, 0x963a, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xb632, 0x532a, 0x8d19, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2a11, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0x9642, 0xc710, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6c21, 0x743a, 0xd742, 0xd742, 0xd842, 0xd73a, 0xd73a, 0xd73a, 0xd73a, 0xd73a, 0xd73a, 0xd73a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0x9532, 0x8c19, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe710, 0xd732, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xb74a, 0xb74a, 0xb74a, 0xb74a, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0x9642, 0xa610, 0x0000, 0x0000, 0x0000, 0x0000, 0xa510, 0x5332, 0xd742, 0xd742, 0xd742, 0xd73a, 0xd742, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0x742a, 0xa508, 0x0000, 0x0000, 0x0000, 0x0000, 0xc608, 0xd732, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xb742, 0xc710, 0x0000, 0x0000, 0x0000, 0x0000, 0x2a19, 0xb63a, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xd732, 0x4a11, 0x0000, 0x0000, 0x0000, 0x0000, 0xe710, 0xf832, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xb742, 0xd742, 0x0919, 0x0000, 0x0000, 0x0000, 0x0000, 0x6c21, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x8c19, 0x0000, 0x0000, 0x0000, 0x0000, 0x2a11, 0x1833, 0xf832, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xb742, 0xb742, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb742, 0xd742, 0xae29, 0x0000, 0x0000, 0x0000, 0x0000, 0x6c21, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x8c19, 0x0000, 0x0000, 0x0000, 0x0000, 0xce19, 0x1833, 0xf82a, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb742, 0xd742, 0x533a, 0x6308, 0x0000, 0x0000, 0x0000, 0x2a19, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4a11, 0x0000, 0x0000, 0x0000, 0x6408, 0x952a, 0x1933, 0x1833, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb742, 0xb742, 0x0919, 0x0000, 0x0000, 0x0000, 0xa510, 0xb63a, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0x9532, 0xcf21, 0xcf21, 0x9532, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xd732, 0xa508, 0x0000, 0x0000, 0x0000, 0x2a11, 0xf82a, 0xf82a, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb742, 0xd742, 0xf031, 0x4200, 0x0000, 0x0000, 0x2100, 0x5332, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xb63a, 0x8408, 0x0000, 0x0000, 0x8408, 0xb632, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x742a, 0x2100, 0x0000, 0x0000, 0x4200, 0x3222, 0x192b, 0xf82a, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb642, 0x0919, 0x0000, 0x0000, 0x0000, 0x6c21, 0xb742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xf83a, 0x8d21, 0x0000, 0x0000, 0x0000, 0x0000, 0x8d19, 0xf83a, 0xf832, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0xf832, 0x8c19, 0x0000, 0x0000, 0x0000, 0x2911, 0xf82a, 0x182b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xb742, 0xd742, 0x3232, 0x4200, 0x0000, 0x0000, 0x4200, 0x753a, 0xd742, 0xd742, 0xd742, 0xd742, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xad21, 0x0000, 0x0000, 0x0000, 0x0000, 0xad21, 0xf83a, 0xf832, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0xf832, 0x1833, 0xb52a, 0x4200, 0x0000, 0x0000, 0x4200, 0x5322, 0x192b, 0x182b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0x6c21, 0x0000, 0x2100, 0x0000, 0x8c21, 0xd73a, 0xd742, 0xd742, 0xd842, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0x9532, 0xa508, 0x0000, 0x0000, 0xa508, 0x9532, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0xf832, 0x8d19, 0x0000, 0x2100, 0x0000, 0xad19, 0x192b, 0x182b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0x953a, 0xc610, 0x0000, 0x0000, 0x2100, 0x5332, 0xd742, 0xd73a, 0xd842, 0xd842, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0x7432, 0xad21, 0xad21, 0x9432, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0xf832, 0x1833, 0x7322, 0x2100, 0x0000, 0x0000, 0xe708, 0xd72a, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0x3232, 0x2100, 0x0000, 0x0000, 0xe710, 0xb63a, 0xd842, 0xd742, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0xd72a, 0xe808, 0x0000, 0x0000, 0x2100, 0x5322, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xcf29, 0x0000, 0x2100, 0x0000, 0x8d21, 0xd842, 0xd73a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xd732, 0xd732, 0xf832, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0xad19, 0x0000, 0x2100, 0x0000, 0xf019, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0xd742, 0x4b19, 0x0000, 0x0000, 0x0000, 0x112a, 0xd83a, 0xd73a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x182b, 0x1933, 0x3122, 0x0000, 0x0000, 0x0000, 0x8c11, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd842, 0xd842, 0xd842, 0xd842, 0xd742, 0xd842, 0xb63a, 0x0811, 0x0000, 0x0000, 0x4208, 0x5332, 0xd83a, 0xd73a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0x7432, 0xe710, 0xe710, 0x742a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x182b, 0x192b, 0x7322, 0x4200, 0x0000, 0x0000, 0x2911, 0xf82a, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, + 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xd83a, 0x953a, 0xa610, 0x0000, 0x0000, 0xa508, 0x9532, 0xd83a, 0xd73a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xc608, 0x0000, 0x0000, 0xc608, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1833, 0x192b, 0xb52a, 0xa508, 0x0000, 0x0000, 0xc608, 0xd622, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, + 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xd83a, 0x7432, 0x8408, 0x0000, 0x0000, 0xc710, 0x963a, 0xd83a, 0xd73a, 0xd83a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x182b, 0x192b, 0xd62a, 0xe708, 0x0000, 0x0000, 0xa508, 0xb522, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, + 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xd83a, 0x7432, 0x6408, 0x0000, 0x0000, 0xe810, 0xb63a, 0xd83a, 0xd73a, 0xd83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf83a, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x182b, 0x192b, 0xd72a, 0x0809, 0x0000, 0x0000, 0x8400, 0xb522, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, + 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xd83a, 0x7432, 0x6408, 0x0000, 0x0000, 0xe810, 0xb63a, 0xd83a, 0xd73a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf83a, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x182b, 0x192b, 0xd72a, 0x0809, 0x0000, 0x0000, 0x8400, 0xb522, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, + 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xd83a, 0x7432, 0x8408, 0x0000, 0x0000, 0xc710, 0xb632, 0xf83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x182b, 0x192b, 0xd62a, 0xe708, 0x0000, 0x0000, 0xa508, 0xb522, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, + 0xd83a, 0xd83a, 0xd83a, 0xd83a, 0xd73a, 0xd83a, 0x9532, 0xa608, 0x0000, 0x0000, 0xa508, 0x9532, 0xf83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x182b, 0x192b, 0xb522, 0xa508, 0x0000, 0x0000, 0xc608, 0xd622, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xb73a, 0x0811, 0x0000, 0x0000, 0x4300, 0x532a, 0xf83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x182b, 0x192b, 0x7422, 0x4200, 0x0000, 0x0000, 0x2911, 0xf82a, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0x6b19, 0x0000, 0x0000, 0x0000, 0x112a, 0xf83a, 0xd83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x182b, 0x192b, 0x3122, 0x0000, 0x0000, 0x0000, 0x8c11, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xd83a, 0xf83a, 0xcf21, 0x0000, 0x2100, 0x0000, 0xad21, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x182b, 0x192b, 0xae19, 0x0000, 0x2100, 0x0000, 0xf019, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xd83a, 0xf83a, 0x322a, 0x2100, 0x0000, 0x0000, 0xe710, 0xb632, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0xd72a, 0xe808, 0x0000, 0x0000, 0x2100, 0x7322, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xb632, 0xc710, 0x0000, 0x0000, 0x2100, 0x532a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0x1833, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x182b, 0x192b, 0x7322, 0x2100, 0x0000, 0x0000, 0xe708, 0xd722, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0x8c19, 0x0000, 0x2100, 0x0000, 0x8d19, 0xd732, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0x1833, 0xf832, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0xf82a, 0xad11, 0x0000, 0x2100, 0x0000, 0xad11, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xd73a, 0xf83a, 0x322a, 0x4200, 0x0000, 0x0000, 0x4200, 0x9532, 0xf83a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0x1833, 0xf832, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0xb622, 0x4200, 0x0000, 0x0000, 0x4200, 0x7322, 0x392b, 0x192b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xd732, 0x2911, 0x0000, 0x0000, 0x0000, 0x8c19, 0xf732, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x4200, 0x0000, 0x0000, 0x4200, 0x1833, 0xf832, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0xf82a, 0x8c11, 0x0000, 0x0000, 0x0000, 0x2a11, 0x182b, 0x192b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf83a, 0xf832, 0xf832, 0x1122, 0x4200, 0x0000, 0x0000, 0x2100, 0x742a, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x4200, 0x0000, 0x0000, 0x4200, 0x1833, 0xf832, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x9422, 0x2100, 0x0000, 0x0000, 0x4200, 0x521a, 0x392b, 0x1923, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x2911, 0x0000, 0x0000, 0x0000, 0xa508, 0xd732, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0xc608, 0x0000, 0x0000, 0xc608, 0x1833, 0x182b, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0xf82a, 0xa508, 0x0000, 0x0000, 0x0000, 0x4a11, 0x192b, 0x192b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x742a, 0x6408, 0x0000, 0x0000, 0x0000, 0x4a11, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0xb62a, 0x2911, 0x2911, 0xb62a, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x4a11, 0x0000, 0x0000, 0x0000, 0x8400, 0xb522, 0x392b, 0x192b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xcf21, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c19, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0xf832, 0x1833, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x8c11, 0x0000, 0x0000, 0x0000, 0x0000, 0xef19, 0x392b, 0x1923, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x2a11, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c19, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x8d11, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a11, 0x392b, 0x1923, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xe710, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a11, 0xd732, 0x1833, 0x1833, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0xf72a, 0x4a11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0809, 0x192b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xd732, 0xc608, 0x0000, 0x0000, 0x0000, 0x0000, 0xa508, 0x742a, 0xf832, 0x1833, 0x1833, 0xf832, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x182b, 0x192b, 0x192b, 0x192b, 0x9422, 0xa508, 0x0000, 0x0000, 0x0000, 0x0000, 0xc608, 0xf822, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xd732, 0xe710, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c19, 0x952a, 0x1833, 0x1833, 0x1933, 0x1833, 0xf82a, 0x182b, 0x1833, 0x182b, 0x182b, 0x182b, 0x182b, 0x182b, 0x182b, 0x182b, 0x192b, 0x192b, 0x192b, 0x192b, 0xb522, 0x8c11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe808, 0xf822, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0xf832, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0xf832, 0x2a11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4200, 0xad19, 0x7322, 0xd72a, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0xd72a, 0x7322, 0xad11, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x4a11, 0x192b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, + 0x0000, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0xf832, 0x1833, 0xce19, 0x8408, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x0811, 0xae19, 0x3122, 0x7422, 0xb52a, 0xd72a, 0xf72a, 0xf72a, 0xd72a, 0xb522, 0x7422, 0x3122, 0xae19, 0x0809, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x8400, 0xef19, 0x392b, 0x192b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, + 0x0000, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0xf832, 0x1833, 0x742a, 0x2a11, 0x4200, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x6300, 0xa508, 0xe708, 0x0809, 0x0809, 0xe708, 0xa508, 0x6300, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x4200, 0x4a11, 0x9522, 0x392b, 0x1923, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, + 0x0000, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0xf82a, 0x1933, 0x1933, 0x3122, 0x2a11, 0x4200, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0x0000, 0x0000, 0x0000, 0x4200, 0x4a11, 0x321a, 0x392b, 0x392b, 0x1923, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, + 0x0000, 0x0000, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1833, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x182b, 0x182b, 0x192b, 0x192b, 0x5222, 0xad19, 0xe708, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4200, 0xe708, 0xad11, 0x5322, 0x392b, 0x392b, 0x192b, 0x192b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, + 0x0000, 0x0000, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x182b, 0xf82a, 0x192b, 0x192b, 0x192b, 0xd62a, 0x5322, 0xf019, 0x8c11, 0x2911, 0xc608, 0xa508, 0x8400, 0x8400, 0xa508, 0xc608, 0x2911, 0x8c11, 0xf019, 0x7322, 0xd722, 0x192b, 0x392b, 0x392b, 0x1923, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x1933, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x182b, 0x182b, 0x192b, 0x192b, 0x192b, 0x192b, 0xf72a, 0xd62a, 0xb522, 0xb522, 0xb522, 0xb522, 0xd622, 0xf82a, 0x192b, 0x192b, 0x192b, 0x392b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x192b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x392b, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x3923, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Setting_64x64.c b/Firmware/Images/Image_Setting_64x64.c new file mode 100644 index 0000000..518b4c7 --- /dev/null +++ b/Firmware/Images/Image_Setting_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Setting_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4200, 0x4a09, 0xef11, 0x941a, 0x1823, 0x7a23, 0xbc2b, 0xde2b, 0xde2b, 0xbc2b, 0x7a23, 0x1823, 0x941a, 0xef11, 0x4a09, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc608, 0x3112, 0x3923, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x3923, 0x3112, 0xc608, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0xcd11, 0x5923, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x5923, 0xcd11, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4200, 0xef11, 0xbc2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xbc2b, 0xef11, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b09, 0x9c23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xbc23, 0xad11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8400, 0x1723, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x1723, 0x8400, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4909, 0xbc2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xbd2b, 0x4a09, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x311a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x3112, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x941a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x931a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd51a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xd51a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x731a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x941a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x311a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x3012, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a09, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x4a09, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8400, 0xbd2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xbd2b, 0x8400, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1723, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xf722, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8c11, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x6b11, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x4200, 0x9c23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x577d, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0xd495, 0x6e8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0x6f8d, 0xd274, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x9c23, 0x4100, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0f12, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xef11, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x2100, 0xbc2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xbc23, 0x2100, 0x0000, 0x0000, + 0x0000, 0x0000, 0xcd11, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xad11, 0x0000, 0x0000, + 0x0000, 0x0000, 0x3923, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x8dce, 0x6dce, 0xc5bd, 0xe5bd, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x5923, 0x0000, 0x0000, + 0x0000, 0xc608, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x4b73, 0xca62, 0xc641, 0x4652, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xc508, 0x0000, + 0x0000, 0x3112, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x4b73, 0xca62, 0xc641, 0x4652, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x3012, 0x0000, + 0x0000, 0x3923, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xbaf7, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0x6d7b, 0xca62, 0xc641, 0x6852, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x15e7, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x3923, 0x0000, + 0x4200, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xbbf7, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x6d7b, 0xca62, 0xc641, 0x6952, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x17ef, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x4200, + 0x4a09, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xbbf7, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x6d7b, 0xca62, 0xc641, 0x6952, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x17ef, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xfe2b, 0x2909, + 0xef11, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x30e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x6b73, 0xca62, 0xc641, 0x4652, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x69ce, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0xfe2b, 0xef11, + 0x941a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x4b73, 0xca62, 0xc641, 0x4652, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0xde2b, 0x731a, + 0x3823, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x8cb5, 0x4cad, 0x6594, 0xa59c, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0xe662, 0xe662, 0xe662, 0xa67b, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xdd22, 0x1823, + 0x7b23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0xc641, 0xc641, 0xc641, 0xe662, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbc22, + 0xbc23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x75ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0xf4e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xc641, 0xc641, 0xc641, 0xe662, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, + 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xbbf7, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0xc641, 0xc641, 0xc641, 0xe662, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, + 0xde2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xbbf7, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0xc641, 0xc641, 0xc641, 0xe662, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, + 0xbc23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x75ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0x97ef, 0xf4e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xf2e6, 0xc641, 0xc641, 0xc641, 0xe662, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbd22, + 0x7b23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0xc641, 0xc641, 0xc641, 0xe662, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbd22, + 0x3823, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xccbd, 0x4cad, 0x4cad, 0x4cad, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0xe662, 0xe662, 0xe662, 0xa67b, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbc22, + 0x941a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xeb83, 0xca62, 0xca62, 0xca62, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x991a, + 0xef11, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xeb83, 0xca62, 0xca62, 0xca62, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x31e7, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x8ad6, 0x69ce, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x361a, + 0x4a09, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xeb83, 0xca62, 0xca62, 0xca62, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x17ef, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xaf11, + 0x4200, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xeb83, 0xca62, 0xca62, 0xca62, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x7df7, 0x17ef, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x6400, + 0x0000, 0x3923, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xeb83, 0xca62, 0xca62, 0xca62, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x5bf7, 0x15e7, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9c22, 0x0000, + 0x0000, 0x3112, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xeb83, 0xca62, 0xca62, 0xca62, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x571a, 0x0000, + 0x0000, 0xc608, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xeb83, 0xca62, 0xca62, 0xca62, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x0a09, 0x0000, + 0x0000, 0x0000, 0x3923, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0xadd6, 0x8dd6, 0x8dd6, 0x8dd6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbc22, 0x0000, 0x0000, + 0x0000, 0x0000, 0xcd11, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x141a, 0x0000, 0x0000, + 0x0000, 0x0000, 0x2100, 0xbc2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x4300, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xef11, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0x52b6, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x0ddf, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x45c6, 0x4b9d, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x361a, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x4200, 0x9c23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xf67c, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0x3495, 0xee8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0xce8c, 0x526c, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbd22, 0x6300, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8b11, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xd111, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1723, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9b22, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8400, 0xbd2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xc708, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a09, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xb011, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3112, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x571a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x731a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x991a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xd51a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9a1a, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x731a, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x991a, 0x2100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3012, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x571a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2909, 0xbc2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xb011, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8400, 0xf722, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9b22, 0xc708, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b09, 0x9c23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xf311, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4100, 0xef11, 0xbc23, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x361a, 0x6300, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2100, 0xad11, 0x3923, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbc22, 0x141a, 0x4200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc508, 0x3012, 0x3923, 0xfe2b, 0xfe2b, 0xfe2b, 0xde2b, 0xdd22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbc22, 0x571a, 0x0a09, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4200, 0x2909, 0xef11, 0x931a, 0x1823, 0xbc22, 0x9d22, 0x9d22, 0x9d22, 0x9d22, 0xbd22, 0xbc22, 0x991a, 0x361a, 0xaf11, 0x6400, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Steel_Blue_Jam_Happy_64x64.c b/Firmware/Images/Image_Steel_Blue_Jam_Happy_64x64.c new file mode 100644 index 0000000..f53a79b --- /dev/null +++ b/Firmware/Images/Image_Steel_Blue_Jam_Happy_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Steel_Blue_Jam_Happy_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x2ac4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x4ac4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x29bc, 0xa8ab, 0x879b, 0x879b, 0x879b, 0x87a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88a3, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa8ab, 0xa9b3, 0xa9b3, 0xa9b3, 0xc9bb, 0x4acc, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x679b, 0x045a, 0x0229, 0xa118, 0x8118, 0x8118, 0x8118, 0x8118, 0x8118, 0x8118, 0x8118, 0x8118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xa118, 0xe228, 0xe459, 0x68a3, 0x6bd4, 0x6ad4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x0000, 0x0000, + 0x0000, 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x4793, 0xc120, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6110, 0x0793, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x0000, 0x0000, + 0x0000, 0x09bc, 0x09bc, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x09bc, 0xc8ab, 0x2231, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x0000, 0x8118, 0xa9b3, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x0000, + 0x0000, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0xa67a, 0x2008, 0x0000, 0x0000, 0x4008, 0x4339, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x6341, 0x8341, 0x8341, 0x8341, 0x8341, 0x8341, 0x8341, 0x8341, 0x8349, 0x8349, 0x8349, 0x8349, 0x8349, 0x8349, 0x8349, 0xa120, 0x0000, 0x2008, 0x0000, 0x456a, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x0000, + 0x0000, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x2462, 0x0000, 0x2000, 0x0000, 0x656a, 0xe8b3, 0xe9b3, 0xe9b3, 0xe9b3, 0xe9b3, 0xe9b3, 0xe9b3, 0xe9b3, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09bc, 0x09c4, 0x09c4, 0x09c4, 0x09c4, 0x09c4, 0x09c4, 0x09c4, 0x09c4, 0x09c4, 0x0ac4, 0x0ac4, 0x0ac4, 0x2ac4, 0x2ac4, 0x2ac4, 0x2acc, 0x0793, 0x4008, 0x0000, 0x0000, 0xa451, 0x4ad4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x0000, + 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x045a, 0x0000, 0x2008, 0x0000, 0x679b, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0x4ac4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0xc9bb, 0xa118, 0x0000, 0x0000, 0x8349, 0x2acc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x045a, 0x0000, 0x2008, 0x0000, 0x2793, 0x29bc, 0x09bc, 0x29bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x2ac4, 0x2ac4, 0x2acc, 0x2acc, 0x2acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4acc, 0x4ad4, 0xa9b3, 0xa118, 0x0000, 0x0000, 0x8349, 0x2acc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x045a, 0x0000, 0x2008, 0x0000, 0x479b, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0x4ac4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0xc9b3, 0xa118, 0x0000, 0x0000, 0x8349, 0x2acc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x045a, 0x0000, 0x2008, 0x0000, 0x656a, 0x2793, 0x068b, 0x068b, 0x068b, 0x068b, 0x078b, 0x078b, 0x078b, 0x078b, 0x078b, 0x078b, 0x078b, 0x078b, 0x078b, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x0793, 0x2793, 0x2793, 0x2793, 0x2793, 0x2793, 0x2793, 0x2793, 0x2793, 0x2793, 0x489b, 0xa682, 0x6110, 0x0000, 0x0000, 0x8349, 0x2acc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09bc, 0x29bc, 0x0462, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8349, 0x2acc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x88a3, 0xe228, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x279b, 0x6bdc, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x29bc, 0x09b4, 0x6341, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa118, 0xa9b3, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29bc, 0x29c4, 0x29bc, 0xe451, 0x0000, 0x2000, 0x0000, 0x2008, 0xa349, 0x045a, 0xe451, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0xe459, 0x045a, 0x045a, 0x045a, 0x0462, 0x0462, 0x0462, 0x0462, 0x0462, 0x0462, 0x0562, 0x0562, 0x0562, 0x0562, 0xe459, 0xa118, 0x0000, 0x0000, 0x0000, 0x4339, 0x0acc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29bc, 0x29c4, 0x8572, 0x0000, 0x0000, 0x0000, 0x2000, 0x456a, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0x4ac4, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x289b, 0x4008, 0x0000, 0x2000, 0x0000, 0xc459, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x078b, 0x2008, 0x0000, 0x0000, 0x0000, 0xc451, 0x09bc, 0x29bc, 0x29bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x09c4, 0x29c4, 0x49c4, 0x4ac4, 0x4ac4, 0x4acc, 0x29c4, 0x29c4, 0x29c4, 0x2ac4, 0x2ac4, 0x2acc, 0x2acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2acc, 0x2acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6bd4, 0xa682, 0x2000, 0x0000, 0x0000, 0x0000, 0x6672, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, + 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x88a3, 0xa118, 0x0000, 0x0000, 0x0000, 0x2239, 0xa8ab, 0x09bc, 0x09bc, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0xe9bb, 0x2793, 0xe68a, 0x88ab, 0x4acc, 0x4acc, 0x4acc, 0x29c4, 0x2ac4, 0x2acc, 0x2acc, 0x4acc, 0x4acc, 0x2acc, 0x2acc, 0x4acc, 0x4acc, 0x4acc, 0xa8ab, 0xe78a, 0x279b, 0x2acc, 0x6ad4, 0x6ad4, 0x4ad4, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6bdc, 0x4572, 0x4008, 0x0000, 0x0000, 0x0000, 0x0793, 0x6bdc, 0x6bdc, 0x8bdc, + 0x29c4, 0x29c4, 0x29c4, 0x09bc, 0x4239, 0x0000, 0x0000, 0x0000, 0x4008, 0xe68a, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x29c4, 0x68a3, 0xa67a, 0x6341, 0x2000, 0x0000, 0xc220, 0x456a, 0x479b, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x09c4, 0x279b, 0x2562, 0xc120, 0x0000, 0x2008, 0xa449, 0xe78a, 0xc9bb, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x0ac4, 0x0793, 0x8118, 0x0000, 0x0000, 0x0000, 0x8118, 0xeac3, 0x6bdc, 0x8bdc, + 0x29c4, 0x29c4, 0x29c4, 0xc8b3, 0x0000, 0x2008, 0x0000, 0x0000, 0x4008, 0x0231, 0xe459, 0x8572, 0xc682, 0x2793, 0x0793, 0xe68a, 0x867a, 0x2462, 0x8341, 0xa120, 0x0000, 0x0000, 0x0000, 0x2008, 0x0000, 0x0000, 0x8118, 0xa349, 0x6572, 0xe78a, 0x479b, 0x88a3, 0x68a3, 0x279b, 0xc682, 0x2562, 0x4341, 0x4008, 0x0000, 0x0000, 0x2008, 0x0000, 0x0000, 0x0000, 0x0231, 0xe459, 0x867a, 0x0793, 0x289b, 0x489b, 0x289b, 0xe792, 0x867a, 0x0562, 0x4341, 0x8118, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x289b, 0x6bdc, 0x8bdc, + 0x29c4, 0x29c4, 0x29c4, 0x09bc, 0x6339, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x6110, 0x6110, 0x4008, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x2000, 0x0000, 0x0000, 0x0000, 0x2008, 0x0000, 0x0000, 0x0000, 0x4008, 0x8118, 0xc120, 0xa120, 0x6110, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x6110, 0x6110, 0x6110, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc220, 0x0ac4, 0x8bdc, 0x8bdc, + 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0xc8b3, 0x2462, 0x4010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x6341, 0xc451, 0x6110, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x0000, 0x0000, 0x0000, 0xa118, 0xe459, 0x6341, 0x0000, 0x0000, 0x0000, 0x2000, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0231, 0x6672, 0xa9b3, 0x6bdc, 0x8bdc, 0x8bdc, + 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x689b, 0x6572, 0x2231, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2008, 0x2231, 0x456a, 0x479b, 0x09bc, 0x29c4, 0x68a3, 0x8672, 0x4341, 0x4008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa118, 0xa451, 0xc682, 0xa8ab, 0x4acc, 0x09c4, 0x279b, 0x0562, 0x0231, 0x2008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8118, 0x256a, 0x48a3, 0xeac3, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, + 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x49c4, 0xe9b3, 0xc451, 0x0000, 0x2000, 0x0000, 0x6341, 0xe459, 0x0462, 0x867a, 0x2793, 0x88a3, 0xe9bb, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x09bc, 0xa8ab, 0x489b, 0xc682, 0x6572, 0x2562, 0x256a, 0x8672, 0xe78a, 0x88a3, 0xc9b3, 0x2acc, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0xe9bb, 0xa9b3, 0x48a3, 0xe78a, 0x867a, 0x6672, 0xa682, 0x456a, 0x6110, 0x0000, 0x0000, 0x6341, 0x4ad4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, + 0x49c4, 0x49c4, 0x49c4, 0x49c4, 0x49c4, 0x29c4, 0x29c4, 0x29c4, 0x49c4, 0x256a, 0x0000, 0x2008, 0x0000, 0x279b, 0x29c4, 0x29c4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0xc9bb, 0xa118, 0x0000, 0x0000, 0x8449, 0x4ad4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, + 0x49c4, 0x49c4, 0x49c4, 0x49c4, 0x4ac4, 0x4ac4, 0x4ac4, 0x29c4, 0x2ac4, 0x0562, 0x0000, 0x2008, 0x0000, 0x689b, 0x4acc, 0x4acc, 0x4acc, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0xa9b3, 0xa118, 0x0000, 0x0000, 0x8349, 0x2ad4, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, + 0x4ac4, 0x4ac4, 0x4ac4, 0x4ac4, 0x4ac4, 0x4ac4, 0x4ac4, 0x29c4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x489b, 0x4acc, 0x4ac4, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0xa9b3, 0xa120, 0x0000, 0x0000, 0x8349, 0x2ad4, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x29c4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x489b, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bd4, 0x6bdc, 0xa9b3, 0xa120, 0x0000, 0x0000, 0x8349, 0x2ad4, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x29c4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x489b, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bd4, 0x6bdc, 0xa9b3, 0xa120, 0x0000, 0x0000, 0x8349, 0x2ad4, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x29c4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x489b, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0xe9bb, 0xc682, 0xe78a, 0x29c4, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x2acc, 0x0793, 0xc78a, 0x0ac4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bd4, 0x6bdc, 0xa9b3, 0xa120, 0x0000, 0x0000, 0x8349, 0x2ad4, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x29c4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x489b, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x29c4, 0x8349, 0x0000, 0x0000, 0x6572, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x4ad4, 0x4572, 0x0000, 0x0000, 0xa449, 0x2acc, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bd4, 0x6bdc, 0xa9b3, 0xa120, 0x0000, 0x0000, 0x8349, 0x2ad4, 0x8bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2ac4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0xa8b3, 0xa120, 0x0000, 0x0000, 0x8349, 0x4acc, 0x4ad4, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x4acc, 0x8449, 0x0000, 0x0000, 0xc120, 0xc9bb, 0x6bd4, 0x6ad4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8349, 0x2ad4, 0x8bdc, 0x6bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2ac4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2ac4, 0x456a, 0x6110, 0xa118, 0xe78a, 0x4ad4, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0xe78a, 0xa118, 0x6110, 0x4572, 0x4acc, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8349, 0x4ad4, 0x8bdc, 0x6bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2ac4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x0793, 0x68a3, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x88ab, 0x279b, 0x4ad4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4ad4, 0x8bdc, 0x6bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2ac4, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4acc, 0x4ad4, 0x4acc, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4ad4, 0x8bdc, 0x6bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2acc, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x6ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x4ad4, 0x6bd4, 0x4ad4, 0x4ad4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4ad4, 0x8bdc, 0x6bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2acc, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0xe9bb, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0xe9c3, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x6bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2acc, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4acc, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x2acc, 0xe459, 0xc120, 0x4341, 0xe9c3, 0x6ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x09c4, 0x6341, 0xc220, 0x0562, 0x4ad4, 0x6bdc, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x2562, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4ad4, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x4acc, 0x6ad4, 0x0793, 0x2008, 0x0000, 0x0000, 0x0231, 0xa8ab, 0x6ad4, 0x6ad4, 0x88ab, 0x0231, 0x0000, 0x0000, 0x4008, 0x489b, 0x6bdc, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4acc, 0x4ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4ad4, 0x4acc, 0x4ad4, 0x4ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x489b, 0x6110, 0x0000, 0x0000, 0x0000, 0x6110, 0x0231, 0x0231, 0x6110, 0x0000, 0x0000, 0x0000, 0x8118, 0x68ab, 0x6bdc, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4acc, 0x4ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x4ad4, 0x4acc, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x4ad4, 0x667a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6672, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4acc, 0x4ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x6ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0xa682, 0x4008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4008, 0xc682, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, + 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4acc, 0x6ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x6ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0xc9bb, 0x0562, 0x6110, 0x2008, 0x2008, 0x6110, 0x0562, 0xc9bb, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x6bdc, 0x8bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, + 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4acc, 0x6ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x6ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x2acc, 0x2acc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x6bdc, 0x8bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, + 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4acc, 0x6ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x6ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x6bdc, 0x8be4, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, + 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4acc, 0x6ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x6ad4, 0x4ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x6bdc, 0x8be4, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, + 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4acc, 0x6ad4, 0x256a, 0x0000, 0x2008, 0x0000, 0x68a3, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x6bdc, 0x6bdc, 0xc9bb, 0xa120, 0x0000, 0x0000, 0x8449, 0x4bd4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, + 0x0000, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0x4572, 0x0000, 0x2008, 0x0000, 0x2793, 0x6ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4ad4, 0x4bd4, 0x4bd4, 0x4bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x4bdc, 0x8be4, 0xc9bb, 0x4010, 0x0000, 0x0000, 0xa451, 0x6bdc, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x0000, + 0x0000, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x4ad4, 0x6ad4, 0xa682, 0x2000, 0x0000, 0x0000, 0x4339, 0xe9bb, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x4bd4, 0x0562, 0x0000, 0x2008, 0x0000, 0x4572, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x0000, + 0x0000, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6ad4, 0x6bd4, 0x6ad4, 0x6bd4, 0xe9bb, 0xc228, 0x0000, 0x0000, 0x0000, 0x0231, 0x0562, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x256a, 0x456a, 0x456a, 0x456a, 0x456a, 0x456a, 0x4572, 0x4572, 0x4572, 0x4572, 0x4572, 0x6349, 0x0000, 0x0000, 0x0000, 0x4008, 0x48a3, 0x8be4, 0x6be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x0000, + 0x0000, 0x0000, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x4ad4, 0x6bd4, 0x867a, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0xc459, 0x4bdc, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x0000, 0x0000, + 0x0000, 0x0000, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x6ad4, 0x4ad4, 0x2acc, 0x256a, 0x0000, 0x0000, 0x0000, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2000, 0x0000, 0x0000, 0x6341, 0x0acc, 0x8ce4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8cec, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x6bd4, 0x6bd4, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bd4, 0x6bdc, 0x4ad4, 0x0793, 0x4341, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xe230, 0x8682, 0x2ad4, 0x8ce4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8cec, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x0acc, 0xa9b3, 0x88ab, 0x68ab, 0x68ab, 0x68ab, 0x68ab, 0x68ab, 0x68ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x88ab, 0x89ab, 0x89ab, 0x89ab, 0x89ab, 0x89ab, 0x89ab, 0x89ab, 0x89ab, 0x89ab, 0x89b3, 0x89b3, 0x89b3, 0x89b3, 0x89b3, 0x89b3, 0x89b3, 0x89b3, 0xa9bb, 0x0acc, 0x8be4, 0x8ce4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8cec, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8cec, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8cec, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8cec, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x6bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8bdc, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8be4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x8ce4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Images/Image_Stone_Blue_Light_On_64x64.c b/Firmware/Images/Image_Stone_Blue_Light_On_64x64.c new file mode 100644 index 0000000..901ecd3 --- /dev/null +++ b/Firmware/Images/Image_Stone_Blue_Light_On_64x64.c @@ -0,0 +1,75 @@ +#include + + + +const uint16_t _Image_Stone_Blue_Light_On_64x64[3 + 4096] = { + 64, // Image Width + 64, // Image Height + 16, // Image Data Size + + // Image Data + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xec83, 0xec8b, 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x2d94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xec83, 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x2d94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xec83, 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x2d94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xf1ac, 0xf1ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xac83, 0xcc83, 0xec83, 0xec83, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x2d94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xb0a4, 0xf0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xac83, 0xcc83, 0xcc83, 0xac7b, 0x4752, 0x2321, 0x6852, 0xcc83, 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x2d94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xb0a4, 0x0a6b, 0x6431, 0xea62, 0xb0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xac83, 0xcc83, 0xac83, 0xcc83, 0x885a, 0x0000, 0x0000, 0x0000, 0xe641, 0xcc83, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x2d94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xb0a4, 0x6852, 0x0000, 0x0000, 0x0000, 0x4b73, 0xf1ac, 0xd0a4, 0xf1ac, 0x11ad, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xac83, 0xcc83, 0x6852, 0x0000, 0x2000, 0x2000, 0x0000, 0x274a, 0xcc83, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x2d8c, 0x0d8c, 0x2e94, 0x2e94, 0x4e94, 0x2e94, 0xed8b, 0xcc83, 0xac83, 0xac83, 0xcd83, 0x0d8c, 0x6e9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xa95a, 0x0000, 0x2000, 0x2000, 0x0000, 0x2b6b, 0xf1ac, 0xd0a4, 0xf1ac, 0x11ad, 0x11ad, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0x6b7b, 0x4429, 0x0000, 0x0000, 0x2000, 0x2000, 0x6b7b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d94, 0x2e94, 0x0d8c, 0x4b73, 0xa95a, 0xe641, 0x4429, 0xe320, 0xc218, 0xc218, 0xe320, 0x6431, 0x0642, 0xc962, 0x8b7b, 0x4e94, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0x2e8c, 0x2000, 0x2000, 0x2000, 0x0000, 0xa539, 0x6f9c, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x0000, 0x0000, + 0x0000, 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0x6b7b, 0x2429, 0x0000, 0x0000, 0x6108, 0x8b7b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d94, 0x0d8c, 0xa95a, 0xa539, 0x6108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6110, 0xc639, 0xea62, 0x6f94, 0x8f9c, 0x8f9c, 0x8f9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0x4e94, 0x8110, 0x0000, 0x0000, 0x8531, 0x4f94, 0xf1ac, 0xf0a4, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x0000, 0x0000, + 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xec83, 0x8b7b, 0xe641, 0x6431, 0xc962, 0xed8b, 0x0d8c, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x0a6b, 0x6431, 0x0000, 0x0000, 0x0000, 0x2000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x2000, 0x0000, 0x0000, 0x0000, 0x8531, 0x6b73, 0x8f9c, 0x8f9c, 0xaf9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xb0a4, 0x6b73, 0xc639, 0x4852, 0x6f94, 0xf0ac, 0xd0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x0000, + 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xec83, 0xec83, 0xec83, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x274a, 0x6108, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x8210, 0x0321, 0x4429, 0x6429, 0x2429, 0xa210, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0x6108, 0x6852, 0x8f9c, 0xaf9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xd0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x0000, + 0x0000, 0xcc83, 0xcc83, 0xcc83, 0xcc83, 0xec83, 0xec83, 0xec8b, 0xec8b, 0xed8b, 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0xed8b, 0x8531, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0xc218, 0x274a, 0x0a6b, 0x8b7b, 0xcc83, 0xed8b, 0x0d8c, 0xed8b, 0xac7b, 0x0a6b, 0x474a, 0xc218, 0x0000, 0x0000, 0x2000, 0x0000, 0x0000, 0xc639, 0x6f9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x0000, + 0xec83, 0xec83, 0xec83, 0xec83, 0xec83, 0xec8b, 0xec8b, 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x6431, 0x0000, 0x0000, 0x2000, 0x0000, 0x8110, 0x8852, 0xac7b, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0xed83, 0xa95a, 0x8110, 0x0000, 0x2000, 0x0000, 0x0000, 0xa539, 0x8f9c, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, + 0xec8b, 0xec8b, 0xec8b, 0xec8b, 0xec8b, 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0xc539, 0x0000, 0x0000, 0x0000, 0x0000, 0x4429, 0xac7b, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xed83, 0x6431, 0x0000, 0x0000, 0x0000, 0x0000, 0x0742, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, + 0xec8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0xa95a, 0x0000, 0x0000, 0x0000, 0x0000, 0xa539, 0x0d8c, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x4e94, 0xe641, 0x0000, 0x0000, 0x0000, 0x0000, 0x2a6b, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, + 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0xcc83, 0x6108, 0x0000, 0x0000, 0x0000, 0x6431, 0x2d8c, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xa539, 0x0000, 0x0000, 0x0000, 0x6108, 0x6f9c, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, + 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0xc641, 0x0000, 0x0000, 0x0000, 0xe320, 0x0d8c, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0x6f9c, 0x0321, 0x0000, 0x0000, 0x0000, 0x274a, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, + 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0xcc83, 0x4008, 0x0000, 0x0000, 0x4008, 0x0a6b, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0x8f9c, 0xb0a4, 0x4b73, 0x4108, 0x0000, 0x0000, 0x4108, 0x6f9c, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, + 0x0d8c, 0x0d8c, 0xed8b, 0xed8b, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x474a, 0x0000, 0x0000, 0x0000, 0x4429, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xb0a4, 0x8f9c, 0xb0a4, 0x6531, 0x0000, 0x0000, 0x0000, 0xa95a, 0xd0a4, 0xd0a4, 0xf0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, + 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x0d8c, 0x2d8c, 0x0d8c, 0x2d94, 0xe318, 0x0000, 0x0000, 0x2000, 0x2a6b, 0x4e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0x6c7b, 0x2000, 0x0000, 0x0000, 0x0321, 0xd0a4, 0xd0a4, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, 0x32b5, + 0x0d8c, 0x0d8c, 0xed8b, 0x4b73, 0x2a6b, 0x2a6b, 0x2a6b, 0x2a6b, 0xac7b, 0x0d8c, 0x2d8c, 0x2d8c, 0x0d8c, 0x2d8c, 0xed83, 0x4108, 0x0000, 0x0000, 0x8110, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0x8210, 0x0000, 0x0000, 0x4108, 0x8f9c, 0xd0a4, 0xd0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0x6f9c, 0xed83, 0xed83, 0xed8b, 0xed8b, 0x2e8c, 0xf1ac, 0x32b5, 0x32b5, + 0x0d8c, 0x0d8c, 0x0642, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc218, 0x6b73, 0x2d8c, 0x0d8c, 0x2d8c, 0x2e94, 0x0a63, 0x2000, 0x0000, 0x0000, 0x8531, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xa539, 0x0000, 0x0000, 0x4008, 0x8c7b, 0xf0a4, 0xf0a4, 0xd0a4, 0xf1ac, 0x0e8c, 0x0321, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x895a, 0x32b5, 0x32b5, + 0x0d8c, 0x0d8c, 0x0000, 0x2000, 0x2000, 0x2000, 0x2008, 0x4008, 0x0000, 0x074a, 0x2d94, 0x0d8c, 0x2d8c, 0x2e94, 0x6852, 0x0000, 0x0000, 0x0000, 0x474a, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xa95a, 0x0000, 0x0000, 0x2000, 0xea62, 0xf0ac, 0xd0a4, 0xd0a4, 0xf1ac, 0x8852, 0x0000, 0x4108, 0x4108, 0x4008, 0x4008, 0x2000, 0x0000, 0x32b5, 0x32b5, + 0x2d8c, 0x2d8c, 0x6431, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6108, 0xea6a, 0x2e94, 0x2d8c, 0x2e94, 0x2e94, 0x274a, 0x0000, 0x0000, 0x0000, 0xa85a, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0x2b6b, 0x0000, 0x0000, 0x0000, 0x6852, 0xf1ac, 0xd0a4, 0xf0a4, 0xf1ac, 0x8c7b, 0x8110, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc639, 0x32b5, 0x32b5, + 0x2d94, 0x2d94, 0xcc83, 0x4752, 0x074a, 0x074a, 0x074a, 0x074a, 0x0a6b, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x0642, 0x0000, 0x0000, 0x0000, 0x0a6b, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0x4b73, 0x2000, 0x0000, 0x0000, 0x4852, 0xf1ac, 0xd0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0x8c7b, 0x8852, 0x8852, 0x8852, 0x8852, 0xea62, 0xb0a4, 0x32b5, 0x32b5, + 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x274a, 0x0000, 0x0000, 0x0000, 0xe962, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xb0a4, 0xd0a4, 0x2b6b, 0x0000, 0x0000, 0x0000, 0x6852, 0xf1ac, 0xf0a4, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, + 0x2e94, 0x2e94, 0x2e94, 0x0d8c, 0x2d8c, 0x2d8c, 0x2d8c, 0x2d8c, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x2e94, 0x4e94, 0x8852, 0x0000, 0x0000, 0x0000, 0x6852, 0x4e94, 0x4e94, 0x6e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xa95a, 0x0000, 0x0000, 0x2000, 0xea62, 0xf1ac, 0xf0ac, 0xf1ac, 0x11ad, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x32b5, 0x32b5, 0x32b5, + 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x2e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x0a6b, 0x2008, 0x0000, 0x0000, 0xa539, 0x4e94, 0x4e94, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xb0a4, 0xd0a4, 0xc639, 0x0000, 0x0000, 0x4008, 0x8c7b, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, + 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x0d8c, 0x4108, 0x0000, 0x0000, 0xa210, 0x6e9c, 0x6e94, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xa210, 0x0000, 0x0000, 0x6108, 0xb09c, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, + 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0xe320, 0x0000, 0x0000, 0x2000, 0x4b73, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x8c7b, 0x2000, 0x0000, 0x0000, 0x2321, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, + 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6852, 0x0000, 0x0000, 0x0000, 0x4429, 0x6f9c, 0x6e9c, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x6431, 0x0000, 0x0000, 0x0000, 0xc95a, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, + 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e94, 0x6e94, 0x6e9c, 0x0d8c, 0x4008, 0x0000, 0x0000, 0x2000, 0x0a6b, 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x4b73, 0x4008, 0x0000, 0x0000, 0x4108, 0x8f9c, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, + 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x4e94, 0x6e94, 0x6e94, 0x6e94, 0x6e9c, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x0642, 0x0000, 0x0000, 0x0000, 0xe320, 0x4e94, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xb09c, 0xe320, 0x0000, 0x0000, 0x0000, 0x484a, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, + 0x6e94, 0x6e94, 0x6e94, 0x6e94, 0x6e94, 0x6e94, 0x6e94, 0x6e9c, 0x6e9c, 0x6e9c, 0x6f94, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x0e8c, 0x6108, 0x0000, 0x0000, 0x0000, 0x6431, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xb0a4, 0x8531, 0x0000, 0x0000, 0x0000, 0x6110, 0x909c, 0xf1ac, 0x11ad, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, + 0x6e9c, 0x6e9c, 0x6e9c, 0x6e9c, 0x6e9c, 0x6e9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0xea62, 0x0000, 0x0000, 0x0000, 0x0000, 0xe641, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xb0a4, 0x0742, 0x0000, 0x0000, 0x0000, 0x0000, 0x4b73, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, + 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x4e94, 0x2a6b, 0xa85a, 0xcd83, 0x6f9c, 0x6f9c, 0x6f9c, 0x8f9c, 0xe641, 0x0000, 0x0000, 0x0000, 0x0000, 0x885a, 0x8f9c, 0x8f9c, 0xaf9c, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xa95a, 0x0000, 0x0000, 0x0000, 0x0000, 0x274a, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x4e94, 0xea62, 0x8c7b, 0xf1ac, 0x31ad, 0x11ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, + 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x4e94, 0x274a, 0x0000, 0x0000, 0xe318, 0x2e8c, 0x8f9c, 0x8f9c, 0x8f9c, 0x6f9c, 0x8531, 0x0000, 0x0000, 0x0000, 0xc218, 0xed8b, 0xaf9c, 0x8f9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x2e8c, 0xe318, 0x0000, 0x0000, 0x0000, 0xa539, 0xd0a4, 0xf1ac, 0xf1ac, 0x11ad, 0xb09c, 0xe320, 0x0000, 0x0000, 0x6852, 0xf1ac, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, + 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x6f9c, 0x4e94, 0x474a, 0x0000, 0x0000, 0x2008, 0x0000, 0xed83, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x4e94, 0x2329, 0x0000, 0x0000, 0x0000, 0xc95a, 0xb0a4, 0x8f9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xb0a4, 0xd0a4, 0xea62, 0x0000, 0x0000, 0x0000, 0x4429, 0xb0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x4f94, 0x0000, 0x4008, 0x0000, 0x0000, 0x895a, 0xf1ac, 0x31ad, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, + 0x6f9c, 0x6f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x6f9c, 0x8f9c, 0x2b6b, 0x4108, 0x2000, 0x2000, 0x0000, 0xa539, 0x4e94, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x6b73, 0x0000, 0x2000, 0x0000, 0x0742, 0xb0a4, 0xaf9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x274a, 0x0000, 0x2000, 0x0000, 0xad83, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0xd0a4, 0xe641, 0x0000, 0x2000, 0x2000, 0x4108, 0xad7b, 0x32b5, 0x32ad, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, + 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x6f9c, 0x8f9c, 0xe962, 0x0000, 0x0000, 0x0000, 0x6431, 0x2e94, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xed8b, 0x6108, 0x0000, 0x0000, 0x6429, 0x4f94, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x8f9c, 0x6531, 0x0000, 0x0000, 0x6108, 0x4e94, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0xb0a4, 0x8531, 0x0000, 0x0000, 0x0000, 0x4b73, 0x32b5, 0x32ad, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, + 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x2e8c, 0x0642, 0xc218, 0xe641, 0x2e94, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0x8f9c, 0xafa4, 0x4e94, 0x6431, 0x0000, 0x0000, 0xa218, 0xac83, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0ac, 0xed83, 0xa218, 0x0000, 0x0000, 0x8531, 0x909c, 0x11ad, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0xb0a4, 0x274a, 0xe318, 0x484a, 0xb0a4, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, + 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x6f9c, 0xcd83, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xaf9c, 0xafa4, 0xafa4, 0xb0a4, 0xb0a4, 0x8f9c, 0x474a, 0x0000, 0x2000, 0x0000, 0x2a6b, 0xd0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xd0a4, 0xf1ac, 0x4b73, 0x2000, 0x2000, 0x0000, 0x6852, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x32b5, 0x31b5, 0x4f94, 0x11ad, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, + 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0x8f9c, 0xafa4, 0xafa4, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0x2b6b, 0x0000, 0x4008, 0x0000, 0x8852, 0xb0a4, 0xb09c, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0ac, 0xa95a, 0x0000, 0x4008, 0x0000, 0x6b73, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72b5, 0x73bd, + 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xaf9c, 0xaf9c, 0xaf9c, 0xaf9c, 0x8f9c, 0x8f9c, 0x8f9c, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xcc83, 0x4008, 0x0000, 0x0000, 0xc641, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xe641, 0x0000, 0x0000, 0x4108, 0xed8b, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x73bd, 0x73bd, + 0xafa4, 0xafa4, 0xafa4, 0xafa4, 0xafa4, 0xafa4, 0xafa4, 0xafa4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0x2e8c, 0x0321, 0x0000, 0x0000, 0x8210, 0xe641, 0x474a, 0x274a, 0x274a, 0x274a, 0x474a, 0x474a, 0x474a, 0x474a, 0x274a, 0x484a, 0x0742, 0x8210, 0x0000, 0x0000, 0x0321, 0x6f94, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x73bd, 0x73bd, 0x73bd, + 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0x8f9c, 0xe641, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0742, 0xd1a4, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, + 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xc95a, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0xea62, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, + 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xb0a4, 0xd0a4, 0x6b73, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c7b, 0x11ad, 0x11ad, 0x31ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, + 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xed83, 0xa218, 0x0000, 0x0000, 0xe320, 0x2a6b, 0xac7b, 0x8c7b, 0x8c7b, 0x8c7b, 0x8c7b, 0x8c7b, 0x8c7b, 0xac7b, 0x2b6b, 0xe320, 0x0000, 0x0000, 0xc218, 0x2e8c, 0x11ad, 0x11ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, + 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0x6f9c, 0x8531, 0x0000, 0x0000, 0x8110, 0x0e8c, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x2e94, 0x8110, 0x0000, 0x0000, 0x8531, 0xb0a4, 0x31ad, 0x11ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, + 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0ac, 0x4852, 0x0000, 0x2008, 0x0000, 0x8c7b, 0xf0ac, 0xf0a4, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xac7b, 0x0000, 0x2008, 0x0000, 0x6852, 0x31b5, 0x11ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, + 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xf0ac, 0xf0ac, 0xd0a4, 0xf0a4, 0x0a6b, 0x0000, 0x2000, 0x0000, 0xc962, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0xca62, 0x0000, 0x2000, 0x0000, 0x2b6b, 0x11ad, 0x11ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, + 0x0000, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xf0a4, 0xf0ac, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xd0a4, 0xf1ac, 0xac7b, 0x6108, 0x0000, 0x0000, 0x0321, 0xed83, 0xb0a4, 0xb0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xed83, 0x0321, 0x0000, 0x0000, 0x6110, 0xed83, 0x32b5, 0x11ad, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x0000, + 0x0000, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xd0a4, 0xf0a4, 0xf0a4, 0xf0ac, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x909c, 0x6531, 0x0000, 0x2000, 0x0000, 0xc218, 0xc639, 0xc639, 0xc639, 0xc639, 0xc639, 0xc639, 0xc218, 0x0000, 0x2000, 0x0000, 0x8531, 0xd0a4, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, + 0x0000, 0xf0a4, 0xf0a4, 0xf0a4, 0xf0a4, 0xf0a4, 0xf0ac, 0xf0ac, 0xf0ac, 0xf0ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x6b73, 0x4008, 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2000, 0x0000, 0x4108, 0x8c7b, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, + 0x0000, 0x0000, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x0a6b, 0x4108, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4108, 0x2b6b, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, + 0x0000, 0x0000, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0xcd83, 0x274a, 0x0321, 0xc218, 0xc218, 0xc218, 0xc218, 0xc218, 0xc218, 0x2421, 0x274a, 0xed83, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x6f9c, 0x4f94, 0x4f94, 0x4f94, 0x4f94, 0x4f94, 0x4f94, 0x8f9c, 0x11ad, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0xf1ac, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x11ad, 0x11ad, 0x31ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x11ad, 0x31ad, 0x31ad, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72b5, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x93bd, 0x93bd, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x11ad, 0x31ad, 0x31ad, 0x31b5, 0x31b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x32b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x52b5, 0x72bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x73bd, 0x93bd, 0x93bd, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; diff --git a/Firmware/Rotary_Encoder.c b/Firmware/Rotary_Encoder.c new file mode 100644 index 0000000..56f542c --- /dev/null +++ b/Firmware/Rotary_Encoder.c @@ -0,0 +1,141 @@ +/* + * Rotary_Encoder.c + * + * Created: Mon Nov 29 2021 11:27:29 + * Author Chris + */ + +// ============================================================================================ +// Includes +#include "Rotary_Encoder.h" + +#include "pico/time.h" +#include "pico/types.h" +#include "pico/stdlib.h" +#include "hardware/gpio.h" + + +// ============================================================================================ +// Defines +#define ENCODER_PIN_A_GPIO 25 +#define ENCODER_PIN_B_GPIO 24 +#define ENCODER_SWITCH_GPIO 27 + +#define GPIO_IRQ_LEVEL_LOW 1 +#define GPIO_IRQ_LEVEL_HIGH 2 +#define GPIO_IRQ_EDGE_FALL 4 +#define GPIO_IRQ_EDGE_RISE 8 + +#define SWITCH_IDLE 1 +#define SWITCH_PRESSED 0 + +#define DEBOUNCE_TIME_ENCODER_MS 50 +#define DEBOUNCE_TIME_SWITCH_MS 300 + + +// ============================================================================================ +// Variables +static volatile uint32_t _Debounce_Time_Encoder_ms = 0; +static volatile uint32_t _Debounce_Time_Switch_ms = 0; + +static volatile bool _Rotation_CW_Occurred; +static volatile bool _Rotation_CCW_Occurred; +static volatile bool _Switch_Press_Occurred; + +static volatile uint8_t _Rotary_Encoder_Previous_NextCode = 0; +static volatile uint16_t _Rotary_Encoder_Store_State = 0; +static volatile int8_t _Rotary_Encoder_Table[] = { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 }; + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Interrupt Service Routines +*******************************************************************/ +void ISR_Rotary_Encoder(uint gpio, uint32_t events) +{ + if(gpio == ENCODER_PIN_A_GPIO || gpio == ENCODER_PIN_B_GPIO) + { + _Rotary_Encoder_Previous_NextCode <<= 2; + if(gpio_get(ENCODER_PIN_A_GPIO)) { _Rotary_Encoder_Previous_NextCode |= 0x02; } + if(gpio_get(ENCODER_PIN_B_GPIO)) { _Rotary_Encoder_Previous_NextCode |= 0x01; } + _Rotary_Encoder_Previous_NextCode &= 0x0f; + + // If valid then _Rotary_Encoder_Store_State as 16 bit data. + if(_Rotary_Encoder_Table[_Rotary_Encoder_Previous_NextCode]) + { + _Rotary_Encoder_Store_State <<= 4; + _Rotary_Encoder_Store_State |= _Rotary_Encoder_Previous_NextCode; + + if((_Rotary_Encoder_Store_State & 0xFF)==0x2B) { _Rotation_CCW_Occurred = true; } + if((_Rotary_Encoder_Store_State & 0xFF)==0x17) { _Rotation_CW_Occurred = true; } + } + } + else if(gpio == ENCODER_SWITCH_GPIO) + { + uint32_t Current_Time_ms = to_ms_since_boot(get_absolute_time()); + + if(Current_Time_ms < _Debounce_Time_Switch_ms) + { + return; + } + + _Switch_Press_Occurred = true; + + _Debounce_Time_Switch_ms = Current_Time_ms + DEBOUNCE_TIME_SWITCH_MS; + } +} + + +/******************************************************************* + Functions +*******************************************************************/ +void Rotary_Encoder_Init(void) +{ + _Rotation_CW_Occurred = false; + _Rotation_CCW_Occurred = false; + _Switch_Press_Occurred = false; + + + gpio_init(ENCODER_PIN_A_GPIO); gpio_set_dir(ENCODER_PIN_A_GPIO, false); + gpio_init(ENCODER_PIN_B_GPIO); gpio_set_dir(ENCODER_PIN_B_GPIO, false); + gpio_init(ENCODER_SWITCH_GPIO); gpio_set_dir(ENCODER_SWITCH_GPIO, false); + + gpio_set_irq_enabled_with_callback(ENCODER_PIN_A_GPIO, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true, &ISR_Rotary_Encoder); + gpio_set_irq_enabled(ENCODER_PIN_B_GPIO, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true); + gpio_set_irq_enabled(ENCODER_SWITCH_GPIO, GPIO_IRQ_EDGE_FALL , true); +} + +bool Rotary_Encoder_Rotation_CW_Occurred(void) +{ + bool Return_Value = _Rotation_CW_Occurred; + + _Rotation_CW_Occurred = false; + + return Return_Value; +} + +bool Rotary_Encoder_Rotation_CCW_Occurred(void) +{ + bool Return_Value = _Rotation_CCW_Occurred; + + _Rotation_CCW_Occurred = false; + + return Return_Value; +} + +bool Rotary_Encoder_Switch_Press_Occurred(void) +{ + bool Return_Value = _Switch_Press_Occurred; + + _Switch_Press_Occurred = false; + + return Return_Value; +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ diff --git a/Firmware/Rotary_Encoder.h b/Firmware/Rotary_Encoder.h new file mode 100644 index 0000000..47219c5 --- /dev/null +++ b/Firmware/Rotary_Encoder.h @@ -0,0 +1,32 @@ +/* + * Rotary_Encoder.h + * + * Created: Mon Nov 29 2021 11:25:57 + * Author Chris + */ +#ifndef ROTARY_ENCODER_H_ +#define ROTARY_ENCODER_H_ + +// ============================================================================================ +// Includes +#include + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Datatypes + + +// ============================================================================================ +// Function Declarations +void Rotary_Encoder_Init(void); + +bool Rotary_Encoder_Rotation_CW_Occurred(void); +bool Rotary_Encoder_Rotation_CCW_Occurred(void); +bool Rotary_Encoder_Switch_Press_Occurred(void); + + +#endif /* ROTARY_ENCODER_H_ */ diff --git a/Firmware/Screen_Variables.c b/Firmware/Screen_Variables.c new file mode 100644 index 0000000..88a8b45 --- /dev/null +++ b/Firmware/Screen_Variables.c @@ -0,0 +1,24 @@ +/* + * Screen_Variables.c + * + * Created: Fri Apr 02 2021 13:46:29 + * Author Chris + */ + +// ============================================================================================ +// Includes +#include "Screens.h" +#include "pico/types.h" + + +// ============================================================================================ +// Variables +void (*_Screen_Tick)(void); +void (*_Screen_Click)(uint button_return_value); +void (*_Screen_Touch_Event)(int16_t x, int16_t y); +void (*_Screen_Action_CW)(Object_ID object_id); +void (*_Screen_Action_CCW)(Object_ID object_id); +void (*_Screen_On_Objects_Focused)(Object_ID object_id); +void (*_Screen_On_Objects_Defocused)(Object_ID object_id); +void (*_Screen_On_Object_Select)(Object_ID object_id); +void (*_Screen_On_Object_Deselect)(Object_ID object_id); \ No newline at end of file diff --git a/Firmware/Screens.h b/Firmware/Screens.h new file mode 100644 index 0000000..3f7cfb2 --- /dev/null +++ b/Firmware/Screens.h @@ -0,0 +1,47 @@ +/* + * Screens.h + * + * Created: Fri Apr 02 2021 13:46:52 + * Author Chris + */ + +#ifndef SCREENS_H_ +#define SCREENS_H_ + +// ============================================================================================ +// Includes +#include +#include +#include + +#include "Easings.h" +#include "Display_Objects_Datatypes.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables (do not edit) +extern void (*_Screen_Tick)(void); +extern void (*_Screen_Click)(uint button_return_value); +extern void (*_Screen_Touch_Event)(int16_t x, int16_t y); +extern void (*_Screen_Action_CW)(Object_ID object_id); +extern void (*_Screen_Action_CCW)(Object_ID object_id); +extern void (*_Screen_On_Objects_Focused)(Object_ID object_id); +extern void (*_Screen_On_Objects_Defocused)(Object_ID object_id); +extern void (*_Screen_On_Object_Select)(Object_ID object_id); +extern void (*_Screen_On_Object_Deselect)(Object_ID object_id); + + +// ============================================================================================ +// List of all Screen Setups as extern +extern void Screen_Setup_Loading(); +extern void Screen_Setup_Menu_Main(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration, bool do_menu_animation, uint32_t selected_entry); +extern void Screen_Setup_Settings(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration); + +extern void Screen_Setup_Select_RGB(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration, RGB_Color* rgb_color); + + +#endif /* SCREENS_H_ */ \ No newline at end of file diff --git a/Firmware/Screens_Display/Screen_Loading.c b/Firmware/Screens_Display/Screen_Loading.c new file mode 100644 index 0000000..adcca85 --- /dev/null +++ b/Firmware/Screens_Display/Screen_Loading.c @@ -0,0 +1,362 @@ +/* + * Screen_Loading.c + * + * Created: Fri Apr 02 2021 14:34:01 + * Author Chris + */ + +// ============================================================================================ +// Includes +#include "../Screens.h" +#include "../Display_Default_Configurations.h" + +#include "../Version.h" +#include "../Display.h" +#include "../Display_Color.h" +#include "../Display_Objects.h" + + +// ============================================================================================ +// Defines +#define LOADING_MAX 100 + +#define DOT_ANIMATION_SPEED 8 +#define TEXT_CHANGE_INTERVAL 25 +#define PROGRESS_UPDATE_DELAY 2 + +// Logo fade-in animation settings +#define LOGO_FADE_START_FRAME 40 // Frame when logo starts appearing +#define LOGO_FADE_DURATION 25 // Frames to complete fade-in +#define LOGO_HOLD_DURATION 35 // Frames to hold at full opacity before transition + +// Clean Monochromatic Colors (RGB565) +#define COLOR_BACKGROUND 0x0000 // Pure black #000000 +#define COLOR_TEXT_PRIMARY 0xBEF7 // Off-white #F5F5F5 +#define COLOR_TEXT_SECONDARY 0x1084 // Medium gray #808080 +#define COLOR_PROGRESS_TRACK 0x4529 // Dark track #252832 +#define COLOR_PROGRESS_FILL 0xFBDE // Light gray #DEDEDE +#define COLOR_DOT_ACTIVE 0xFFFF // Pure white #FFFFFF +#define COLOR_DOT_INACTIVE 0x0842 // Dark gray #404450 + + +// ============================================================================================ +// Variables +extern const unsigned char _Font_Victor_Mono_Bold_8x19[]; +extern const unsigned char _Font_Victor_Mono_Regular_6x11[]; +extern const unsigned char _Font_Victor_Mono_Regular_7x13[]; +extern const unsigned char _Font_DejaVu_Sans_Mono_10x17[]; +extern const unsigned char _Font_DejaVu_Sans_Mono_6x12[]; +extern const unsigned char _Font_DejaVu_Sans_Mono_Bold_Oblique_10x19[]; + +extern const uint16_t _Image_Fad_Logo_Background_160x160[]; + +static Object_ID _Object_Progress_Track; +static Object_ID _Object_Progress_Fill; +static Object_ID _Object_Loading_Text; +static Object_ID _Object_Status_Text; +static Object_ID _Object_Version_Text; +static Object_ID _Object_Dots[3]; +static Object_ID _Object_Logo_Image; + +static int32_t _Counter; +static int32_t _Loading_Value; +static int32_t _Post_Load_Wait; +static int32_t _Animation_Counter; +static int32_t _Dot_Animation_Phase; +static int32_t _Text_Phase; +static int32_t _Logo_Blend_Phase; +static int32_t _Logo_Fade_Counter; + +// Loading status messages +static char* _Loading_Messages[] = { + "Initializing system...", + "Loading configuration...", + "Preparing interface...", + "Setting up hardware...", + "Configuring display...", + "Loading resources...", + "Finalizing setup...", + "Ready to start!" +}; +static const int _Message_Count = 8; + + +// ============================================================================================ +// Function Declarations +void Screen_Setup_Loading(); + +static void Screen_Tick (void); +static void Screen_Click (uint button_return_value); +static void Screen_Touch_Event (int16_t x, int16_t y); +static void Screen_Action_CW (Object_ID object_id); +static void Screen_Action_CCW (Object_ID object_id); +static void Screen_On_Object_Focused (Object_ID object_id); +static void Screen_On_Object_Defocused (Object_ID object_id); +static void Screen_On_Object_Select (Object_ID object_id); +static void Screen_On_Object_Deselect (Object_ID object_id); + +// Helper functions +static void Update_Dot_Animation(void); +static void Update_Status_Text(void); +static void Update_Logo_Fade_Animation(void); +static float Smooth_Fade_Curve(float t); + + +/******************************************************************* + Functions +*******************************************************************/ +void Screen_Setup_Loading() +{ + _Screen_Tick = Screen_Tick; + _Screen_Click = Screen_Click; + _Screen_Touch_Event = Screen_Touch_Event; + _Screen_Action_CW = Screen_Action_CW; + _Screen_Action_CCW = Screen_Action_CCW; + _Screen_On_Objects_Focused = Screen_On_Object_Focused; + _Screen_On_Objects_Defocused = Screen_On_Object_Defocused; + _Screen_On_Object_Select = Screen_On_Object_Select; + _Screen_On_Object_Deselect = Screen_On_Object_Deselect; + + Display_Objects_Clear(); + + // Initialize variables + _Loading_Value = 0; + _Animation_Counter = 0; + _Dot_Animation_Phase = 0; + _Text_Phase = 0; + _Post_Load_Wait = 0; + _Logo_Blend_Phase = 0; + _Logo_Fade_Counter = 0; + + // Create fonts + Font_ID Font_Primary = Display_Objects_Add_Font(_Font_DejaVu_Sans_Mono_10x17, 1); + Font_ID Font_Secondary = Display_Objects_Add_Font(_Font_Victor_Mono_Regular_6x11, 0); + Font_ID Font_Micro = Display_Objects_Add_Font(_Font_Victor_Mono_Regular_6x11, 0); + + + ////////////////////////////// + // Add Display Objects here // + ////////////////////////////// + + // Progress bar background track + _Object_Progress_Track = Display_Objects_Add_Rectangle_Filled(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 45, NOT_SELECTABLE, COLOR_PROGRESS_TRACK, DISPLAY_WIDTH - 60, 8, NO_STYLE, NO_ANIMATION); + + // Progress bar fill + _Object_Progress_Fill = Display_Objects_Add_Value_Bar_Rect(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 45, NOT_SELECTABLE, &_Loading_Value, LOADING_MAX, 0, LEFT_TO_RIGHT, COLOR_PROGRESS_FILL, DISPLAY_WIDTH - 60, 8, NO_STYLE, NO_ANIMATION); + + // Three dots positioned below progress bar + for(int i = 0; i < 3; i++) { + _Object_Dots[i] = Display_Objects_Add_Circle_Frame(CENTER_MIDDLE, BOTH_IN_PERCENT, 46 + (i * 4), 55, NOT_SELECTABLE, COLOR_DOT_INACTIVE, 3, 1, NO_STYLE, NO_ANIMATION); + } + + // Main loading text, // Above progress bar + _Object_Loading_Text = Display_Objects_Add_Text(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 35, NOT_SELECTABLE, "Loading", Font_Primary, COLOR_TEXT_PRIMARY, NO_STYLE, NO_ANIMATION); + + // Dynamic status text // Below dots + _Object_Status_Text = Display_Objects_Add_Text(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 65, NOT_SELECTABLE, _Loading_Messages[0], Font_Secondary, COLOR_TEXT_SECONDARY, NO_STYLE, NO_ANIMATION); + + // Version text (minimal, bottom corner) + char version_string[16]; + sprintf(version_string, "v%s", VERSION_BUILD_STRING); + _Object_Version_Text = Display_Objects_Add_Text(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 96, NOT_SELECTABLE, version_string, Font_Micro, COLOR_TEXT_SECONDARY, NO_STYLE, NO_ANIMATION); + + + + + // Logo image (initially disabled, will be shown during blend) + _Object_Logo_Image = Display_Objects_Add_Image(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 50, NOT_SELECTABLE, _Image_Fad_Logo_Background_160x160, 0, NO_STYLE, NO_ANIMATION); + Display_Objects_Update_Enabled(_Object_Logo_Image, false); + Display_Objects_Update_Alpha(_Object_Logo_Image, 0); + + Display_Select_First_Object(); + Display_Select_Object(); + + _Counter = 0; +} + +void Screen_Tick(void) +{ + _Animation_Counter++; + + // Update loading progress + if(_Loading_Value < LOADING_MAX) { + if(_Animation_Counter % PROGRESS_UPDATE_DELAY == 0) { + _Loading_Value++; + } + } + + // Update animated dots + Update_Dot_Animation(); + + // Update status text periodically + if(_Animation_Counter % TEXT_CHANGE_INTERVAL == 0) { + Update_Status_Text(); + } + + // Handle completion + if(_Loading_Value >= LOADING_MAX) + { + _Post_Load_Wait++; + + if(_Post_Load_Wait == 20) + { + // Set all dots to active state + for(int i = 0; i < 3; i++) { + Display_Objects_Update_Color(_Object_Dots[i], COLOR_DOT_ACTIVE); + } + Display_Objects_Update_Text(_Object_Status_Text, "Complete!"); + // Recenter the completion text + Display_Objects_Update_Coordinates(_Object_Status_Text, CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 65); + } + else if(_Post_Load_Wait >= 25 && _Post_Load_Wait < LOGO_FADE_START_FRAME) + { + // Start fading out loading elements early (15 frames before logo appears) + float Fade_Factor = (float)(_Post_Load_Wait - 25) / (LOGO_FADE_START_FRAME - 25); + + // Apply smooth easing curve for more natural fade + Fade_Factor = Smooth_Fade_Curve(Fade_Factor); + + // Calculate faded colors for loading elements + Display_Color Faded_Primary = Display_Color_Interpolate_Float(COLOR_TEXT_PRIMARY , COLOR_BACKGROUND, Fade_Factor); + Display_Color Faded_Secondary = Display_Color_Interpolate_Float(COLOR_TEXT_SECONDARY , COLOR_BACKGROUND, Fade_Factor); + Display_Color Faded_Progress = Display_Color_Interpolate_Float(COLOR_PROGRESS_FILL , COLOR_BACKGROUND, Fade_Factor); + Display_Color Faded_Dots = Display_Color_Interpolate_Float(COLOR_DOT_ACTIVE , COLOR_BACKGROUND, Fade_Factor); + Display_Color Faded_Track = Display_Color_Interpolate_Float(COLOR_PROGRESS_TRACK , COLOR_BACKGROUND, Fade_Factor); + + // Apply faded colors + Display_Objects_Update_Color(_Object_Loading_Text, Faded_Primary); + Display_Objects_Update_Color(_Object_Status_Text, Faded_Secondary); + Display_Objects_Update_Color(_Object_Version_Text, Faded_Secondary); + Display_Objects_Update_Color(_Object_Progress_Fill, Faded_Progress); + Display_Objects_Update_Color(_Object_Progress_Track, Faded_Track); + + for(int i = 0; i < 3; i++) { + Display_Objects_Update_Color(_Object_Dots[i], Faded_Dots); + } + } + else if(_Post_Load_Wait >= LOGO_FADE_START_FRAME) + { + Update_Logo_Fade_Animation(); + + if(_Post_Load_Wait >= LOGO_FADE_START_FRAME + LOGO_FADE_DURATION + LOGO_HOLD_DURATION) + { + Screen_Setup_Menu_Main(TRANSITION_LEFT, TRANSITION_NONE, INOUT_SINE, 25, true, 3); + } + } + } +} + +void Screen_Click(uint button_return_value) +{ + +} + +void Screen_Touch_Event(int16_t x, int16_t y) +{ + +} + +void Screen_Action_CW(Object_ID object_id) +{ + +} + +void Screen_Action_CCW(Object_ID object_id) +{ + +} + +void Screen_On_Object_Focused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Defocused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Select(Object_ID object_id) +{ + +} + +void Screen_On_Object_Deselect(Object_ID object_id) +{ + +} + +/******************************************************************* + Internal Functions +*******************************************************************/ +static void Update_Dot_Animation(void) +{ + // Only animate dots while loading + if(_Loading_Value >= LOADING_MAX) return; + + _Dot_Animation_Phase++; + if(_Dot_Animation_Phase >= (DOT_ANIMATION_SPEED * 3)) { + _Dot_Animation_Phase = 0; + } + + // Determine which dot should be active + int active_dot = _Dot_Animation_Phase / DOT_ANIMATION_SPEED; + + // Update dot colors + for(int i = 0; i < 3; i++) { + Display_Color dot_color = (i == active_dot) ? COLOR_DOT_ACTIVE : COLOR_DOT_INACTIVE; + Display_Objects_Update_Color(_Object_Dots[i], dot_color); + } +} + +static void Update_Status_Text(void) +{ + // Only update text while loading + if(_Loading_Value >= LOADING_MAX) return; + + // Calculate which message to show based on progress + int message_index = (_Loading_Value * _Message_Count) / LOADING_MAX; + if(message_index >= _Message_Count) { + message_index = _Message_Count - 1; + } + + // Update the status text + Display_Objects_Update_Text(_Object_Status_Text, _Loading_Messages[message_index]); +} + +static void Update_Logo_Fade_Animation(void) +{ + // Enable logo on first frame if not already enabled + if(_Logo_Fade_Counter == 0) { + Display_Objects_Update_Enabled(_Object_Logo_Image, true); + } + + _Logo_Fade_Counter++; + + // Calculate fade progress (0.0 to 1.0) + float Fade_Progress = (float)_Logo_Fade_Counter / (float)LOGO_FADE_DURATION; + + // Clamp to valid range + if(Fade_Progress > 1.0f) { + Fade_Progress = 1.0f; + } + + // Apply easing for smoother fade-in (ease-out cubic) + float Eased_Progress = Ease_Out_Cubic(Fade_Progress); + + // Convert to alpha value (0-255) + uint8_t Alpha_Value = (uint8_t)(Eased_Progress * 127.0f); + + // Update the logo's alpha + Display_Objects_Update_Alpha(_Object_Logo_Image, Alpha_Value); +} + +static float Smooth_Fade_Curve(float t) +{ + // Smoothstep function for natural easing: 3t² - 2t³ + // Provides smooth acceleration and deceleration + if(t <= 0.0f) return 0.0f; + if(t >= 1.0f) return 1.0f; + + return t * t * (3.0f - 2.0f * t); +} \ No newline at end of file diff --git a/Firmware/Screens_Display/Screen_Menu_Main.c b/Firmware/Screens_Display/Screen_Menu_Main.c new file mode 100644 index 0000000..ac204e0 --- /dev/null +++ b/Firmware/Screens_Display/Screen_Menu_Main.c @@ -0,0 +1,196 @@ +/* + * Screen_Menu_Main.c + * + * Created: Fri Apr 02 2021 14:34:01 + * Author Chris + */ + +// ============================================================================================ +// Includes +#include "../Screens.h" +#include "../UI_Control.h" +#include "../Display_Default_Configurations.h" + +#include "../Display.h" +#include "../Display_Objects.h" + + +// ============================================================================================ +// Defines +#define ENTRY_COUNT 4 + + +// ============================================================================================ +// Variables +extern const unsigned char _Font_DejaVu_Sans_Mono_10x17[]; + +extern const uint16_t _Image_Computer_64x64[]; +extern const uint16_t _Image_Energy_64x64[]; +extern const uint16_t _Image_Music_64x64[]; +extern const uint16_t _Image_Setting_64x64[]; + + +static Object_ID _Object_Ring_Menu; +static int32_t _Ring_Menu_Selected = 0; // 0 = Mode, 1 = MIDI, 2 = Power, 3 = Settings + +// Define your 4 menu items +static Menu_Ring_Item_Config _Ring_Menu_Items[ENTRY_COUNT] = { + { + .Label = "MIDI", + .Icon = _Image_Music_64x64 + }, + { + .Label = "SETUP", + .Icon = _Image_Setting_64x64 + }, + { + .Label = "POWER", + .Icon = _Image_Energy_64x64 + }, + { + .Label = "MODE", + .Icon = _Image_Computer_64x64 + } +}; + +// Ring menu configuration +static Configuration_Menu_Ring _Ring_Menu_Config = { + .Center_Text_Color = DISPLAY_COLOR_FROM_RGB888(100, 181, 246), + .Center_BG_Color = DISPLAY_COLOR_FROM_RGB888(26, 26, 46), + .Center_Border_Color = DISPLAY_COLOR_FROM_RGB888(51, 51, 51), + .Selection_Ring_Color = DISPLAY_COLOR_FROM_RGB888(255, 215, 0), + + .Center_Text_Font = _Font_DejaVu_Sans_Mono_10x17, + + .Item_Radius = 85, + .Center_Size = 90, + .Image_Size = 64, + + .Selection_Ring_Diameter = 0, + .Selection_Ring_Thickness = 3, + .Selection_Ring_Padding = 0, + + .Selection_Scale = 1.15f, + .Animation_Duration = 15, + .Idle_Rotation_Speed = 2.0f, + .Start_Angle_Degrees = 0.0f, + .Distribute_Evenly = true, + .Fixed_Angle_Step = 90.0f, + + .Enable_Appear_Animation = false +}; + + +// ============================================================================================ +// Function Declarations +void Screen_Setup_Menu_Main(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration, bool do_menu_animation, uint32_t selected_entry); + +static void Screen_Tick (void); +static void Screen_Click (uint button_return_value); +static void Screen_Touch_Event (int16_t x, int16_t y); +static void Screen_Action_CW (Object_ID object_id); +static void Screen_Action_CCW (Object_ID object_id); +static void Screen_On_Object_Focused (Object_ID object_id); +static void Screen_On_Object_Defocused (Object_ID object_id); +static void Screen_On_Object_Select (Object_ID object_id); +static void Screen_On_Object_Deselect (Object_ID object_id); + + + +/******************************************************************* + Functions +*******************************************************************/ +void Screen_Setup_Menu_Main(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration, bool do_menu_animation, uint32_t selected_entry) +{ + _Screen_Tick = Screen_Tick; + _Screen_Click = Screen_Click; + _Screen_Touch_Event = Screen_Touch_Event; + _Screen_Action_CW = Screen_Action_CW; + _Screen_Action_CCW = Screen_Action_CCW; + _Screen_On_Objects_Focused = Screen_On_Object_Focused; + _Screen_On_Objects_Defocused = Screen_On_Object_Defocused; + _Screen_On_Object_Select = Screen_On_Object_Select; + _Screen_On_Object_Deselect = Screen_On_Object_Deselect; + + Display_Objects_Clear(); + + Display_Screen_Transition_Start(direction_out, direction_in, type, frame_duration); + + + + ////////////////////////////// + // Add Display Objects here // + ////////////////////////////// + + _Object_Ring_Menu = Display_Objects_Add_Menu_Ring(_Ring_Menu_Items, ENTRY_COUNT, &_Ring_Menu_Selected, &_Ring_Menu_Config); + + if(do_menu_animation) { + Display_Objects_Menu_Ring_Start_Appear_Animation(_Object_Ring_Menu); + } + + Display_Select_First_Object(); + Display_Select_Object(); + + // Initialize values + _Ring_Menu_Selected = 0; + if(selected_entry < ENTRY_COUNT) { + _Ring_Menu_Selected = selected_entry; + } +} + +void Screen_Tick(void) +{ + +} + +void Screen_Click(uint button_return_value) +{ + +} + +void Screen_Touch_Event(int16_t x, int16_t y) +{ + +} + +void Screen_Action_CW(Object_ID object_id) +{ + UI_Control_Selector_Inc(&_Ring_Menu_Selected, 0, ENTRY_COUNT-1, true); +} + +void Screen_Action_CCW(Object_ID object_id) +{ + UI_Control_Selector_Dec(&_Ring_Menu_Selected, 0, ENTRY_COUNT-1, true); +} + +void Screen_On_Object_Focused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Defocused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Select(Object_ID object_id) +{ + +} + +void Screen_On_Object_Deselect(Object_ID object_id) +{ + switch (_Ring_Menu_Selected) + { + case 0: break; + case 1: Screen_Setup_Settings(TRANSITION_UP, TRANSITION_UP, INOUT_SINE, 15); break; + case 2: break; + case 3: break; + } + + Display_Select_Object(); +} + +/******************************************************************* + Internal Functions +*******************************************************************/ diff --git a/Firmware/Screens_Display/Screen_Select_RGB.c b/Firmware/Screens_Display/Screen_Select_RGB.c new file mode 100644 index 0000000..8354756 --- /dev/null +++ b/Firmware/Screens_Display/Screen_Select_RGB.c @@ -0,0 +1,146 @@ +/* + * File: Screen_Select_RGB.c + * + * Created: Created: Friday August 2025 13:35:25 + * Author: Chris + */ + +// ============================================================================================ +// Includes +#include "../Screens.h" +#include "../UI_Control.h" + +#include "../Display.h" +#include "../Display_Objects.h" +#include "../Display_Default_Configurations.h" + + +// ============================================================================================ +// Variables +static Object_ID _RGB_Selector_Object; +static RGB_Color* _RGB_Color; + +static uint8_t _Current_Component; +static uint8_t* _Color; + + +// ============================================================================================ +// Function Declarations +void Screen_Setup_Select_RGB(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration, RGB_Color* rgb_color); + +static void Screen_Tick (void); +static void Screen_Click (uint button_return_value); +static void Screen_Touch_Event (int16_t x, int16_t y); +static void Screen_Action_CW (Object_ID object_id); +static void Screen_Action_CCW (Object_ID object_id); +static void Screen_On_Object_Focused (Object_ID object_id); +static void Screen_On_Object_Defocused (Object_ID object_id); +static void Screen_On_Object_Select (Object_ID object_id); +static void Screen_On_Object_Deselect (Object_ID object_id); + + +/******************************************************************* + Functions +*******************************************************************/ +void Screen_Setup_Select_RGB(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration, RGB_Color* rgb_color) +{ + _Screen_Tick = Screen_Tick; + _Screen_Click = Screen_Click; + _Screen_Touch_Event = Screen_Touch_Event; + _Screen_Action_CW = Screen_Action_CW; + _Screen_Action_CCW = Screen_Action_CCW; + _Screen_On_Objects_Focused = Screen_On_Object_Focused; + _Screen_On_Objects_Defocused = Screen_On_Object_Defocused; + _Screen_On_Object_Select = Screen_On_Object_Select; + _Screen_On_Object_Deselect = Screen_On_Object_Deselect; + + Display_Objects_Clear(); + + Display_Screen_Transition_Start(direction_out, direction_in, type, frame_duration); + + + + ////////////////////////////// + // Add Display Objects here // + ////////////////////////////// + + _Current_Component = 0; + _RGB_Color = rgb_color; + _Color = &(rgb_color->Array[_Current_Component]); + + // Create the RGB selector object + _RGB_Selector_Object = Display_Objects_Add_Select_RGB( + _RGB_Color, // Pointer to color to modify + &_Current_Component, // Indicater for active RGB Base Color + &_Configuration_Default_Select_RGB // Use configuration + ); + + Display_Select_Object(); + + UI_Control_Acceleration_Reset(); + UI_Control_Acceleration_Set_Enabled(true); +} + +void Screen_Tick(void) +{ + +} + +void Screen_Click(uint button_return_value) +{ + +} + +void Screen_Touch_Event(int16_t x, int16_t y) +{ + +} + +void Screen_Action_CW(Object_ID object_id) +{ + int32_t Color = *_Color; + UI_Control_Selector_Inc(&Color, 0, UINT8_MAX, false); + *_Color = (uint8_t)Color; +} + +void Screen_Action_CCW(Object_ID object_id) +{ + int32_t Color = *_Color; + UI_Control_Selector_Dec(&Color, 0, UINT8_MAX, false); + *_Color = (uint8_t)Color; +} + +void Screen_On_Object_Focused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Defocused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Select(Object_ID object_id) +{ + +} + +void Screen_On_Object_Deselect(Object_ID object_id) +{ + if(_Current_Component < 2) { + _Current_Component++; + + _Color = &(_RGB_Color->Array[_Current_Component]); + + Display_Select_Object(); + return; + } + + // Screen_Setup_Menu_Main(TRANSITION_DOWN, TRANSITION_DOWN, INOUT_SINE, 15, false, 1); +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ + diff --git a/Firmware/Screens_Display/Screen_Settings.c b/Firmware/Screens_Display/Screen_Settings.c new file mode 100644 index 0000000..07e347b --- /dev/null +++ b/Firmware/Screens_Display/Screen_Settings.c @@ -0,0 +1,176 @@ +/* + * Screen_Settings.c + * + * Created: Fri Apr 02 2021 14:34:01 + * Author Chris + */ + +// ============================================================================================ +// Includes +#include "../Screens.h" +#include "../UI_Control.h" +#include "../Display_Default_Configurations.h" + +#include "../Display.h" +#include "../Display_Objects.h" + + +// ============================================================================================ +// Defines +#define MENU_ENTRY_COUNT 7 + + +// ============================================================================================ +// Variables +extern const unsigned char _Font_DejaVu_Sans_Mono_10x17[]; +extern const unsigned char _Font_DejaVu_Sans_Mono_Bold_15x26[]; + +extern const uint16_t _Image_Bronze_Copper_Microchip2_64x64[]; +extern const uint16_t _Image_Forest_Pine_Midi_64x64[]; +extern const uint16_t _Image_Midnight_Blue_Back_64x64[]; +extern const uint16_t _Image_Olive_Sage_Diskette_64x64[]; +extern const uint16_t _Image_Rust_Orange_About1_64x64[]; +extern const uint16_t _Image_Steel_Blue_Jam_Happy_64x64[]; +extern const uint16_t _Image_Stone_Blue_Light_On_64x64[]; + +static Object_ID _Object_Menu; + +static Icon_Row_Item _Icon_Row_Items[MENU_ENTRY_COUNT] = { + { _Image_Forest_Pine_Midi_64x64 , TEXT_AND_LENGTH("MIDI to Light") }, + { _Image_Steel_Blue_Jam_Happy_64x64 , TEXT_AND_LENGTH("Jam Mode") }, + { _Image_Stone_Blue_Light_On_64x64 , TEXT_AND_LENGTH("Constant Light") }, + { _Image_Bronze_Copper_Microchip2_64x64 , TEXT_AND_LENGTH("Device") }, + { _Image_Olive_Sage_Diskette_64x64 , TEXT_AND_LENGTH("Save to EEPROM") }, + { _Image_Rust_Orange_About1_64x64 , TEXT_AND_LENGTH("About") }, + { _Image_Midnight_Blue_Back_64x64 , TEXT_AND_LENGTH("Back") } +}; + +static Configuration_Menu_Icon_Row _Configuration_Menu_Icon_Row = { + .Icon_Space_Width = 80, + .Shrink_Factor = 0.25, + .Y_Images = DISPLAY_Y_CENTER, + .Y_Images_Warp = 0, + .Y_Text = DISPLAY_Y_CENTER + 55, + + .Font = _Font_DejaVu_Sans_Mono_10x17, + .Color = DISPLAY_COLOR_LIGHTGREY +}; + +static int32_t _Selected_Item; + + +// ============================================================================================ +// Function Declarations +void Screen_Setup_Settings(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration); + +static void Screen_Tick (void); +static void Screen_Click (uint button_return_value); +static void Screen_Touch_Event (int16_t x, int16_t y); +static void Screen_Action_CW (Object_ID object_id); +static void Screen_Action_CCW (Object_ID object_id); +static void Screen_On_Object_Focused (Object_ID object_id); +static void Screen_On_Object_Defocused (Object_ID object_id); +static void Screen_On_Object_Select (Object_ID object_id); +static void Screen_On_Object_Deselect (Object_ID object_id); + + + +/******************************************************************* + Functions +*******************************************************************/ +void Screen_Setup_Settings(Screen_Transition_Direction direction_out, Screen_Transition_Direction direction_in, Easing type, uint32_t frame_duration) +{ + _Screen_Tick = Screen_Tick; + _Screen_Click = Screen_Click; + _Screen_Touch_Event = Screen_Touch_Event; + _Screen_Action_CW = Screen_Action_CW; + _Screen_Action_CCW = Screen_Action_CCW; + _Screen_On_Objects_Focused = Screen_On_Object_Focused; + _Screen_On_Objects_Defocused = Screen_On_Object_Defocused; + _Screen_On_Object_Select = Screen_On_Object_Select; + _Screen_On_Object_Deselect = Screen_On_Object_Deselect; + + Display_Objects_Clear(); + + Display_Screen_Transition_Start(direction_out, direction_in, type, frame_duration); + + + + ////////////////////////////// + // Add Display Objects here // + ////////////////////////////// + + Style_ID Style_Font = Display_Objects_Add_Style(DISPLAY_COLOR_LIGHTGREY, DISPLAY_COLOR_BLACK, 0, 5, 3, 5, 3, 5, 0); + Font_ID Font_Title = Display_Objects_Add_Font(_Font_DejaVu_Sans_Mono_Bold_15x26, 0); + + + Display_Objects_Add_Text(CENTER_MIDDLE, X_IN_PERCENT_Y_IN_PIXEL, 50, 45, NOT_SELECTABLE, "Settings", Font_Title, DISPLAY_COLOR_LIGHTGREY, NO_STYLE, NO_ANIMATION); + Display_Objects_Add_Rectangle_Filled(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 50, NOT_SELECTABLE, DISPLAY_COLOR_FROM_RGB888(32, 32, 32), DISPLAY_WIDTH, 85, NO_STYLE, NO_ANIMATION); + _Object_Menu = Display_Objects_Add_Menu_Icon_Row(_Icon_Row_Items, MENU_ENTRY_COUNT, &_Selected_Item, &_Configuration_Menu_Icon_Row); + // Display_Objects_Add_Rounded_Rectangle_Frame(CENTER_MIDDLE, BOTH_IN_PERCENT, 50, 50, NOT_SELECTABLE, DISPLAY_COLOR_FROM_RGB888(255, 223, 0), 70, 70, 21, 4, NO_STYLE, NO_ANIMATION); + + _Selected_Item = 0; + + Display_Select_First_Object(); + Display_Select_Object(); +} + +void Screen_Tick(void) +{ + +} + +void Screen_Click(uint button_return_value) +{ + +} + +void Screen_Touch_Event(int16_t x, int16_t y) +{ + +} + +void Screen_Action_CW(Object_ID object_id) +{ + UI_Control_Selector_Inc(&_Selected_Item, 0, MENU_ENTRY_COUNT-1, false); +} + +void Screen_Action_CCW(Object_ID object_id) +{ + UI_Control_Selector_Dec(&_Selected_Item, 0, MENU_ENTRY_COUNT-1, false); +} + +void Screen_On_Object_Focused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Defocused(Object_ID object_id) +{ + +} + +void Screen_On_Object_Select(Object_ID object_id) +{ + +} + +void Screen_On_Object_Deselect(Object_ID object_id) +{ + switch (_Selected_Item) + { + case 0: break; + case 1: break; + case 2: break; + case 3: break; + case 4: break; + case 5: break; + case 6: Screen_Setup_Menu_Main(TRANSITION_DOWN, TRANSITION_DOWN, INOUT_SINE, 15, false, 1); break; + } + + Display_Select_Object(); +} + +/******************************************************************* + Internal Functions +*******************************************************************/ diff --git a/Firmware/UI_Control.c b/Firmware/UI_Control.c new file mode 100644 index 0000000..32f4494 --- /dev/null +++ b/Firmware/UI_Control.c @@ -0,0 +1,262 @@ +/* + * File: UI_Control.c + * + * Created: Created: Friday August 2025 10:21:23 + * Author: Chris + */ +#include "UI_Control.h" + +#include + + +// ============================================================================================ +// Includes + + +// ============================================================================================ +// Defines +#define SELECTOR_INC(__SELECTOR__, __MIN__, __MAX__, __CIRCLE__) if((*__SELECTOR__) < __MAX__) { (*__SELECTOR__)++; } else if(__CIRCLE__) { (*__SELECTOR__) = __MIN__; break; } else { break; } +#define SELECTOR_DEC(__SELECTOR__, __MIN__, __MAX__, __CIRCLE__) if((*__SELECTOR__) > __MIN__) { (*__SELECTOR__)--; } else if(__CIRCLE__) { (*__SELECTOR__) = __MAX__; break; } else { break; } + +// ============================================================================================ +// Variables + +// Default configuration +static const Encoder_Acceleration_Config _Default_Acceleration_Config = { + .Base_Threshold = 5, // Requires more steps to trigger + .Level_Step = 3, // Bigger jumps between levels + .Max_Level = 3, // Fewer levels + .Timeout_ms = 100, // Longer timeout + .Multipliers = {1, 2, 3, 5, 7, 10, 13, 16, 20, 25} +}; + +static Encoder_Acceleration_Instance _Acceleration_Instance; +static bool _Acceleration_Initialized = false; +static bool _Acceleration_Enabled = false; +static uint32_t _Current_Time_MS = 0; + + +// ============================================================================================ +// Function Declarations +uint8_t UI_Control_Acceleration_Process_Step(uint32_t current_time_ms); + + +/******************************************************************* + Functions +*******************************************************************/ +void UI_Control_Init(void) +{ + UI_Control_Acceleration_Init_Custom(&_Default_Acceleration_Config); +} + +void UI_Control_Selector_Inc(int32_t* selector, int32_t minimum, int32_t maximum, bool circle_around) +{ + if (selector == NULL) { + return; + } + + _Current_Time_MS = CURRENT_TIME_ms; + + // Get acceleration multiplier (1 if not initialized or disabled) + uint8_t Increment = UI_Control_Acceleration_Process_Step(_Current_Time_MS); + + // Apply increment with bounds checking + for (uint8_t i = 0; i < Increment; i++) + { + // if(_EEPROM_Content.Device_Configuration.Reverse_List_Scrolling == 0) { + if(true) { + SELECTOR_INC(selector, minimum, maximum, circle_around); + } else { + SELECTOR_DEC(selector, minimum, maximum, circle_around); + } + } +} + +void UI_Control_Selector_Dec(int32_t* selector, int32_t minimum, int32_t maximum, bool circle_around) +{ + if (selector == NULL) { + return; + } + + _Current_Time_MS = CURRENT_TIME_ms; + + // Get acceleration multiplier (1 if not initialized or disabled) + uint8_t Decrement = UI_Control_Acceleration_Process_Step(_Current_Time_MS); + + // Apply decrement with bounds checking + for (uint8_t i = 0; i < Decrement; i++) + { + // if(_EEPROM_Content.Device_Configuration.Reverse_List_Scrolling == 0) { + if(true) { + SELECTOR_DEC(selector, minimum, maximum, circle_around); + } else { + SELECTOR_INC(selector, minimum, maximum, circle_around); + } + } +} + +void UI_Control_Acceleration_Init_Custom(const Encoder_Acceleration_Config* config) +{ + if (config == NULL) { + config = &_Default_Acceleration_Config; + } + + // Clear the instance + memset(&_Acceleration_Instance, 0, sizeof(Encoder_Acceleration_Instance)); + + // Set configuration + _Acceleration_Instance.config = config; + + // Initialize state + _Acceleration_Instance.Speed_Counter = 0; + _Acceleration_Instance.Acceleration_Level = 0; + _Acceleration_Instance.Last_Activity_Time = 0; + _Acceleration_Instance.Total_Steps = 0; + _Acceleration_Instance.Accelerated_Steps = 0; + + _Acceleration_Initialized = true; + _Acceleration_Enabled = false; +} + +void UI_Control_Acceleration_Set_Enabled(bool enable) +{ + _Acceleration_Enabled = enable; + + // Reset state when disabling + if (!enable && _Acceleration_Initialized) { + UI_Control_Acceleration_Reset(); + } +} + +void UI_Control_Acceleration_Reset(void) +{ + if (!_Acceleration_Initialized) { + return; + } + + _Acceleration_Instance.Speed_Counter = 0; + _Acceleration_Instance.Acceleration_Level = 0; + // Don't reset timestamp - let natural timeout handle it +} + +void UI_Control_Set_Current_Time(uint32_t current_time_ms) +{ + _Current_Time_MS = current_time_ms; +} + +void UI_Control_Selector_Inc_Accelerated(int32_t* selector, int32_t minimum, int32_t maximum, bool circle_around, uint32_t current_time_ms) +{ + // This function is now redundant - just call the main function with time set + UI_Control_Set_Current_Time(current_time_ms); + UI_Control_Selector_Inc(selector, minimum, maximum, circle_around); +} + +void UI_Control_Selector_Dec_Accelerated(int32_t* selector, int32_t minimum, int32_t maximum, bool circle_around, uint32_t current_time_ms) +{ + // This function is now redundant - just call the main function with time set + UI_Control_Set_Current_Time(current_time_ms); + UI_Control_Selector_Dec(selector, minimum, maximum, circle_around); +} + +void UI_Control_Acceleration_Update(uint32_t current_time_ms) +{ + if (!_Acceleration_Initialized || _Acceleration_Instance.config == NULL) { + return; + } + + // Check for timeout + if (_Acceleration_Instance.Last_Activity_Time > 0) + { + uint32_t time_since_activity = current_time_ms - _Acceleration_Instance.Last_Activity_Time; + + if (time_since_activity >= _Acceleration_Instance.config->Timeout_ms) { + // Reset acceleration due to timeout + _Acceleration_Instance.Speed_Counter = 0; + _Acceleration_Instance.Acceleration_Level = 0; + // Keep last_activity_time for future timeout calculations + } + } +} + +uint8_t UI_Control_Acceleration_Get_Level(void) +{ + if (!_Acceleration_Initialized) { + return 0; + } + + return _Acceleration_Instance.Acceleration_Level; +} + +bool UI_Control_Acceleration_Is_Active(void) +{ + if (!_Acceleration_Initialized || !_Acceleration_Enabled) { + return false; + } + + return (_Acceleration_Instance.Acceleration_Level > 0); +} + +void UI_Control_Acceleration_Get_Stats(uint32_t* total_steps, uint32_t* accelerated_steps) +{ + if (!_Acceleration_Initialized) + { + if (total_steps) *total_steps = 0; + if (accelerated_steps) *accelerated_steps = 0; + return; + } + + if (total_steps) { + *total_steps = _Acceleration_Instance.Total_Steps; + } + + if (accelerated_steps) { + *accelerated_steps = _Acceleration_Instance.Accelerated_Steps; + } +} + + +/******************************************************************* + Internal Functions +*******************************************************************/ +uint8_t UI_Control_Acceleration_Process_Step(uint32_t current_time_ms) +{ + if (!_Acceleration_Initialized || !_Acceleration_Enabled || _Acceleration_Instance.config == NULL) { + return 1; // Fallback to normal increment + } + + // Use provided time or stored time + uint32_t Time_To_Use = (current_time_ms > 0) ? current_time_ms : _Current_Time_MS; + + const Encoder_Acceleration_Config* Config = _Acceleration_Instance.config; + + // Update activity timestamp + _Acceleration_Instance.Last_Activity_Time = Time_To_Use; + + // Increment speed counter + _Acceleration_Instance.Speed_Counter++; + _Acceleration_Instance.Total_Steps++; + + // Calculate current acceleration level + if (_Acceleration_Instance.Speed_Counter >= Config->Base_Threshold) { + // Calculate level based on how many steps beyond threshold + uint8_t excess_steps = _Acceleration_Instance.Speed_Counter - Config->Base_Threshold; + _Acceleration_Instance.Acceleration_Level = 1 + (excess_steps / Config->Level_Step); + + // Clamp to maximum level + if (_Acceleration_Instance.Acceleration_Level > Config->Max_Level) { + _Acceleration_Instance.Acceleration_Level = Config->Max_Level; + } + } else { + _Acceleration_Instance.Acceleration_Level = 0; + } + + // Get multiplier for current level + uint8_t increment = 1; + if (_Acceleration_Instance.Acceleration_Level > 0) { + // Array is 0-indexed, but level 1 = index 1, level 0 = index 0 + increment = Config->Multipliers[_Acceleration_Instance.Acceleration_Level]; + _Acceleration_Instance.Accelerated_Steps++; + } + + return increment; +} diff --git a/Firmware/UI_Control.h b/Firmware/UI_Control.h new file mode 100644 index 0000000..ea42b58 --- /dev/null +++ b/Firmware/UI_Control.h @@ -0,0 +1,65 @@ +/* + * File: UI_Control.h + * Created: Created: Friday August 2025 10:21:04 + * Author: Chris + */ +#ifndef UI_CONTROL_H +#define UI_CONTROL_H + +// ============================================================================================ +// Includes +#include +#include +#include + +#include "pico/stdlib.h" + + +// ============================================================================================ +// Defines +#define CURRENT_TIME_ms (uint32_t)(time_us_64() / 1000) + + +// ============================================================================================ +// Datatypes +typedef struct { + uint8_t Base_Threshold; // Steps needed to trigger level 1 acceleration + uint8_t Level_Step; // Additional steps per acceleration level + uint8_t Max_Level; // Maximum acceleration level (1-10) + uint16_t Timeout_ms; // Inactivity timeout to reset acceleration (ms) + uint8_t Multipliers[10]; // Multiplier for each acceleration level +} Encoder_Acceleration_Config; + +typedef struct { + // Configuration + const Encoder_Acceleration_Config* config; + + // State tracking + uint8_t Speed_Counter; // Current speed counter + uint8_t Acceleration_Level; // Current acceleration level (0 = no accel) + uint32_t Last_Activity_Time; // Last encoder activity timestamp (ms) + + // Statistics (for debugging) + uint32_t Total_Steps; // Total encoder steps processed + uint32_t Accelerated_Steps; // Steps that used acceleration +} Encoder_Acceleration_Instance; + + +// ============================================================================================ +// Function Declarations +void UI_Control_Init(void); + +void UI_Control_Selector_Inc(int32_t* selector, int32_t minimum, int32_t maximum, bool circle_around); +void UI_Control_Selector_Dec(int32_t* selector, int32_t minimum, int32_t maximum, bool circle_around); + + +void UI_Control_Acceleration_Init_Custom(const Encoder_Acceleration_Config* config); +void UI_Control_Acceleration_Set_Enabled(bool enable); +void UI_Control_Acceleration_Reset(void); +void UI_Control_Acceleration_Update(uint32_t current_time_ms); + +uint8_t UI_Control_Acceleration_Get_Level(void); +bool UI_Control_Acceleration_Is_Active(void); +void UI_Control_Acceleration_Get_Stats(uint32_t* total_steps, uint32_t* accelerated_steps); + +#endif // UI_CONTROL_H \ No newline at end of file diff --git a/Firmware/USB_Serial.c b/Firmware/USB_Serial.c new file mode 100644 index 0000000..0621153 --- /dev/null +++ b/Firmware/USB_Serial.c @@ -0,0 +1,166 @@ +/* + * USB_Serial.c + * + * Created: Sat Mar 20 2021 09:24:20 + * Author Chris + */ +#include "USB_Serial.h" +#include "pico/error.h" +#include "pico/stdlib.h" + + +// ============================================================================================ +// Defines + + +// ============================================================================================ +// Variables +volatile int16_t _Received_Byte; + + +// ============================================================================================ +// Function Declarations + + +/******************************************************************* + Functions +*******************************************************************/ +void USB_Serial_Init(void) +{ + stdio_usb_init(); + + _Received_Byte = PICO_ERROR_TIMEOUT; +} + +//////////////////// +// Receiving Data // +//////////////////// +int16_t USB_Serial_Get_Byte(void) +{ + return _Received_Byte; +} + +bool USB_Serial_Available(void) +{ + _Received_Byte = PICO_ERROR_TIMEOUT; + _Received_Byte = getchar_timeout_us(0); + + return (_Received_Byte != PICO_ERROR_TIMEOUT); +} + +void USB_Serial_Flush_Input(void) +{ + stdio_flush(); +} + +/////////////////////// +// Transmitting Data // +/////////////////////// +bool USB_Serial_Put_Char(uint8_t c) +{ + uint8_t Transmitted_Byte = putchar(c); + + return (Transmitted_Byte == c); +} + +bool USB_Serial_Write(const uint8_t *buffer, uint16_t size) +{ + bool Transmit_Success; + + for(uint16_t i=0;i> ((numbers-i-1) * 4)) & 0x0F; + + if(Hex_Number<10) + Hex_Number = '0' + Hex_Number; + else + Hex_Number = 'A' + (Hex_Number - 10); + + bool Success = USB_Serial_Put_Char(Hex_Number); + if(!Success) { + return false; + } + } + + return true; +} + +bool USB_Serial_Send_Float(float value, uint32_t numbers, uint32_t decimals, bool force_sign) +{ + if(value >=0 && force_sign == true) { + USB_Serial_Put_Char('+'); + } + else if(value < 0) { + USB_Serial_Put_Char('-'); + value = value * -1; + } + + int Int_Part = (int)value; + bool Success = USB_Serial_Send_Int_Dec(Int_Part, numbers); + if(!Success) { + return false; + } + + if(decimals == 0) { + return true; + } + + USB_Serial_Put_Char('.'); + + uint Factor = 1; + for(int i=0;i +#include +#include +#include "inttypes.h" + + +// ============================================================================================ +// Defines +#define USB_SERIAL_TERMINATOR 0x0D + +#define USB_SERIAL_SEND_STRING(_TEXT_) USB_Serial_Write((uint8_t*)_TEXT_, sizeof(_TEXT_)-1) +#define USB_SERIAL_SEND_TERMINATOR() USB_Serial_Put_Char(USB_SERIAL_TERMINATOR); + + +// ============================================================================================ +// Function Declarations +void USB_Serial_Init(void); + + +// Receiving Data +int16_t USB_Serial_Get_Byte(void); // Receive a Byte (-1 if timeout/error) +bool USB_Serial_Available(void); // Number of bytes in receive buffer +void USB_Serial_Flush_Input(void); // Discard any buffered input + +// Transmitting Data +bool USB_Serial_Put_Char(uint8_t c); // Transmit a character +bool USB_Serial_Write(const uint8_t *buffer, uint16_t size); // Transmit a buffer +bool USB_Serial_Send_Int_Dec(int value, uint32_t numbers); +bool USB_Serial_Send_Int_Hex(uint32_t value, uint32_t numbers, bool Send_0x); +bool USB_Serial_Send_Float(float value, uint32_t numbers, uint32_t decimals, bool force_sign); + +#endif /* USB_SERIAL_H_ */ \ No newline at end of file diff --git a/Firmware/build/.gitignore b/Firmware/build/.gitignore new file mode 100644 index 0000000..b726086 --- /dev/null +++ b/Firmware/build/.gitignore @@ -0,0 +1,4 @@ +./* +!./*.txt +!./*.bat +!./*.py \ No newline at end of file diff --git a/Firmware/build/Pico_Reset_And_Program.py b/Firmware/build/Pico_Reset_And_Program.py new file mode 100644 index 0000000..b860817 --- /dev/null +++ b/Firmware/build/Pico_Reset_And_Program.py @@ -0,0 +1,189 @@ +import os +import time +import shutil +import glob +from pathlib import Path +from string import ascii_uppercase +from os import path +import usb.core +import usb.backend.libusb1 + +# Device configurations +DEVICES = { + 'RP2040': { + 'vendor_id': 0x2E8A, + 'product_id': 0x000A, + 'name': 'RP2040' + }, + 'RP2350': { + 'vendor_id': 0x2E8A, + 'product_id': 0x0009, + 'name': 'RP2350' + } +} + +# USB control constants +RESET_INTERFACE = 2 +REQUEST_BOOTSEL = 0x01 +REQUEST_RESET = 0x02 + +# Timing constants +TIMEOUT_THRESHOLD_s = 10 +TIMEOUT_INCREMENT_ms = 100 + +def detect_device(): + """ + Detect which Pico device is connected. + Returns device type string or None if no device found. + """ + print("Auto-detecting connected device...") + + for device_type, config in DEVICES.items(): + device = usb.core.find(idVendor=config['vendor_id'], idProduct=config['product_id']) + if device is not None: + print(f"{config['name']} detected") + return device_type + + return None + +def reset_device_to_bootloader(device_type): + """ + Reset the specified device type to bootloader mode. + """ + config = DEVICES[device_type] + print(f"Resetting {config['name']} to bootloader mode...") + + device = usb.core.find(idVendor=config['vendor_id'], idProduct=config['product_id']) + + if device is None: + print(f'No {config["name"]} device found') + print(f'Make sure your {config["name"]} is connected and not in bootloader mode') + return False + + print(f"{config['name']} device found, attempting to enter bootloader mode...") + + try: + usb.util.claim_interface(device, RESET_INTERFACE) + Request_Type = (0 << 6) | 1 # Standard Request Host-to-Device and to interface + wIndex = RESET_INTERFACE + wValue = 0 # No other data + + device.ctrl_transfer(Request_Type, REQUEST_BOOTSEL, wValue, wIndex, []) + print("Bootloader reset command sent successfully!") + print(f"{config['name']} should now appear as a USB drive for programming") + return True + + except usb.core.USBError as e: + # print(f"USB Error: {e}") + # print("This is normal - the device resets and disconnects") + return True # This is actually expected behavior + except Exception as e: + print(f"Unexpected error: {e}") + return False + finally: + try: + usb.util.release_interface(device, RESET_INTERFACE) + except: + pass # Device may have already disconnected + +def find_uf2_drive(): + """ + Find the UF2 bootloader drive by looking for characteristic files. + Both RP2040 and RP2350 use the same UF2 bootloader mechanism. + """ + for drive in ascii_uppercase: + if path.exists(drive + ":\\INDEX.HTM") and path.exists(drive + ":\\INFO_UF2.TXT"): + return drive + ":\\" + return "" + +def copy_uf2_file(device_type): + """ + Copy the UF2 file to the detected bootloader drive. + """ + print("Looking for UF2 bootloader drive...") + + TARGET_DRIVE = find_uf2_drive() + Timeout_Counter = 0 + + # Wait for drive to appear + while not TARGET_DRIVE: + time.sleep(TIMEOUT_INCREMENT_ms/1000) + TARGET_DRIVE = find_uf2_drive() + + Timeout_Counter = Timeout_Counter + TIMEOUT_INCREMENT_ms + if Timeout_Counter >= TIMEOUT_THRESHOLD_s * 1000: + print(f"Error: Drive for {device_type} could not be found") + return False + + print(f"Found {device_type} drive at: {TARGET_DRIVE}") + + # Change to script directory and find UF2 files + os.chdir(os.path.dirname(os.path.realpath(__file__))) + + uf2_files = glob.glob("./*.uf2") + if len(uf2_files) == 0: + print("Error: No uf2-file has been found") + return False + + print(f"Copying {uf2_files[0]} to {device_type}...") + + try: + shutil.copy(uf2_files[0], TARGET_DRIVE) + print("Copy completed successfully!") + return True + except Exception as e: + print(f"Error copying file: {e}") + return False + +def main(): + """ + Main function to orchestrate the programming process. + """ + print("=== Pico Programmer ===") + + # Detect device + device_type = detect_device() + + if device_type: + # Device found - attempt reset to bootloader + print(f"\n-----------------------") + print(f"Resetting {device_type}...") + print(f"-----------------------") + + # Reset to bootloader + if not reset_device_to_bootloader(device_type): + print("Failed to reset device to bootloader mode") + os._exit(1) + + print(f"\n-----------------------") + print(f"Copying uf2-file...") + print(f"-----------------------") + + # Copy UF2 file + if not copy_uf2_file(device_type): + print("Failed to copy UF2 file") + os._exit(1) + + print(f"\nProgramming {device_type} completed successfully!") + + else: + # No device found - skip reset and try to find bootloader drive directly + print("No supported Pico device found in normal mode") + print("Skipping reset step and looking for existing bootloader drive...") + + print(f"\n-----------------------") + print(f"Looking for bootloader drive...") + print(f"-----------------------") + + # Try to find and copy to existing bootloader drive + if not copy_uf2_file("RP2xxx"): # Generic name since we don't know the specific type + print("No bootloader drive found and no device to reset") + print("Make sure your device is:") + print("1. Connected and in normal mode (for auto-reset), OR") + print("2. Already in bootloader mode (showing as USB drive)") + os._exit(1) + + print(f"\nProgramming completed successfully!") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/Firmware/build/build_number.txt b/Firmware/build/build_number.txt new file mode 100644 index 0000000..80af6ca --- /dev/null +++ b/Firmware/build/build_number.txt @@ -0,0 +1 @@ +6 diff --git a/Firmware/build/build_version.txt b/Firmware/build/build_version.txt new file mode 100644 index 0000000..c227083 --- /dev/null +++ b/Firmware/build/build_version.txt @@ -0,0 +1 @@ +0 \ No newline at end of file diff --git a/Firmware/build/increment_build_number.bat b/Firmware/build/increment_build_number.bat new file mode 100644 index 0000000..438f75e --- /dev/null +++ b/Firmware/build/increment_build_number.bat @@ -0,0 +1,26 @@ +@echo Off + +echo. +echo ----------------------- +echo Updating Build Number... +echo ----------------------- + +set /p version= build_number.txt + +if %new% lss 10 set version_build_string=%version%.000%new% +if %new% geq 10 if %new% lss 100 set version_build_string=%version%.00%new% +if %new% geq 100 if %new% lss 1000 set version_build_string=%version%.0%new% +if %new% geq 1000 set version_build_string=%version%.%new% + +( + echo #define VERSION %version% + echo #define BUILD %new% + echo #define VERSION_BUILD_STRING "%version_build_string%" +) > ..\\Version.h \ No newline at end of file diff --git a/Firmware/build/pico_program_auto.bat b/Firmware/build/pico_program_auto.bat new file mode 100644 index 0000000..078b08a --- /dev/null +++ b/Firmware/build/pico_program_auto.bat @@ -0,0 +1,49 @@ +@echo Off +setlocal enabledelayedexpansion + +echo. +echo ========================= +echo Pico Auto-Programmer +echo ========================= + +REM Read version and build number for file versioning +set /p version=nul 2>&1 +) + +echo. +echo Running unified Pico programmer... +echo. + +REM Call the unified Python script +call python ./Pico_Reset_And_Program.py + +if %errorlevel% == 0 ( + echo. + echo ========================= + echo Programming Success! + echo ========================= +) else ( + echo. + echo ========================= + echo Programming Error + echo ========================= + exit /b 1 +) + +echo. +exit /b \ No newline at end of file diff --git a/Firmware/main.c b/Firmware/main.c new file mode 100644 index 0000000..7dc6ff1 --- /dev/null +++ b/Firmware/main.c @@ -0,0 +1,174 @@ +/* + * main.c + * + * Created: Mon Nov 08 2021 14:06:53 + * Author Chris + */ + +// ============================================================================================ +// Includes +#include + +#include "pico/stdlib.h" + +#include "I2C_Master.h" +#include "UI_Control.h" +#include "Rotary_Encoder.h" + +#include "Display.h" +#include "Display_SPI.h" +#include "Display_Shapes.h" +#include "Screens.h" + +#include "USB_Serial.h" + + +// ============================================================================================ +// Defines +#define LEDG_PIN 12 +#define LEDG_CONFIG gpio_init(LEDG_PIN); gpio_set_dir(LEDG_PIN, GPIO_OUT) +#define LEDG_ON gpio_put(LEDG_PIN, 0) +#define LEDG_OFF gpio_put(LEDG_PIN, 1) +#define LEDG_TOGGLE gpio_put(LEDG_PIN, !gpio_get(LEDG_PIN)) +#define LEDG_ANIMATION_1 LEDG_ON; sleep_ms(100); LEDG_OFF; sleep_ms(100); +#define LEDG_ANIMATION_3 LEDG_ANIMATION_1; LEDG_ANIMATION_1; LEDG_ANIMATION_1 + +#define LEDR_PIN 11 +#define LEDR_CONFIG gpio_init(LEDR_PIN); gpio_set_dir(LEDR_PIN, GPIO_OUT) +#define LEDR_ON gpio_put(LEDR_PIN, 0) +#define LEDR_OFF gpio_put(LEDR_PIN, 1) +#define LEDR_TOGGLE gpio_put(LEDR_PIN, !gpio_get(LEDR_PIN)) + +#define TRIGGER_PIN 18 +#define TRIGGER_CONFIG gpio_init(TRIGGER_PIN); gpio_set_dir(TRIGGER_PIN, GPIO_OUT) +#define TRIGGER_ON gpio_put(TRIGGER_PIN, 1) +#define TRIGGER_OFF gpio_put(TRIGGER_PIN, 0) + + +// ============================================================================================ +// Variables +volatile bool _Timer_Fired = false; + + +// ============================================================================================ +// Function Declarations +void Check_For_Serial_Input(void); + + +/******************************************************************* + Interrupt Service Routines +*******************************************************************/ +bool ISR_Repeating_Timer(struct repeating_timer *t) +{ + LEDG_TOGGLE; + _Timer_Fired = true; + return true; +} + + +/******************************************************************* + Main Routine +*******************************************************************/ +int main(void) +{ + // LED ================================================= + LEDG_CONFIG; + LEDR_CONFIG; LEDR_OFF; + LEDG_ANIMATION_3; + + // Trigger ================================================= + TRIGGER_CONFIG; + TRIGGER_OFF; + + // USB Serial ================================================= + USB_Serial_Init(); + + // Rotary Encoder ============================================= + Rotary_Encoder_Init(); + + // I2C Master ============================================= + I2CM_Init(false); + + // UI Control ================================================= + UI_Control_Init(); + + // Display ================================================= + Display_Init(DISPLAY_COLOR_BLACK, true, false); + // Screen_Setup_Loading(); + Screen_Setup_Menu_Main(TRANSITION_NONE, TRANSITION_NONE, LINEAR, 0, false, 0); + + // Repeating Timer ============================================= + struct repeating_timer Timer; + add_repeating_timer_ms(40, ISR_Repeating_Timer, NULL, &Timer); + + + while (1) + { + if (_Timer_Fired == true) + { + _Timer_Fired = false; + + Display_Send_Buffer(); + Display_Inc_Frame_Counter(); + + Display_Screen_Transition_Tick(); + _Screen_Tick(); + + UI_Control_Acceleration_Update(CURRENT_TIME_ms); + } + + // Add functions here to execute during the DMA Transfer + if(Display_SPI_DMA_Transfer_Ongoing()) + { + + } + + if(Display_Send_Buffer_Completed()) + { + TRIGGER_ON; + Display_Render_Objects(); + TRIGGER_OFF; + } + else + { + Check_For_Serial_Input(); + + if(Rotary_Encoder_Rotation_CW_Occurred()) { + Display_Action_CW(); + } + + if(Rotary_Encoder_Rotation_CCW_Occurred()) { + Display_Action_CCW(); + } + + if(Rotary_Encoder_Switch_Press_Occurred()) { + Display_Action_SW(); + } + } + } +} + +void Check_For_Serial_Input(void) +{ + while(USB_Serial_Available()) + { + uint8_t USB_Data = USB_Serial_Get_Byte(); + switch(USB_Data) + { + case 'a': + USB_SERIAL_SEND_STRING("SPI Baudrate: "); + USB_Serial_Send_Int_Dec(Display_SPI_Get_Baudrate(), 10); + USB_SERIAL_SEND_TERMINATOR(); + break; + + default: + USB_SERIAL_SEND_STRING("Unknown Command: "); + USB_Serial_Put_Char(USB_Data); + USB_SERIAL_SEND_STRING(" ("); + USB_Serial_Send_Int_Hex(USB_Data, 2, true); + USB_SERIAL_SEND_STRING(")"); + USB_SERIAL_SEND_TERMINATOR(); + break; + } + } +} diff --git a/Firmware/pico_sdk_import.cmake b/Firmware/pico_sdk_import.cmake new file mode 100644 index 0000000..d493cc2 --- /dev/null +++ b/Firmware/pico_sdk_import.cmake @@ -0,0 +1,121 @@ +# This is a copy of /external/pico_sdk_import.cmake + +# This can be dropped into an external project to help locate this SDK +# It should be include()ed prior to project() + +# Copyright 2020 (c) 2020 Raspberry Pi (Trading) Ltd. +# +# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +# following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following +# disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +if (DEFINED ENV{PICO_SDK_PATH} AND (NOT PICO_SDK_PATH)) + set(PICO_SDK_PATH $ENV{PICO_SDK_PATH}) + message("Using PICO_SDK_PATH from environment ('${PICO_SDK_PATH}')") +endif () + +if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT} AND (NOT PICO_SDK_FETCH_FROM_GIT)) + set(PICO_SDK_FETCH_FROM_GIT $ENV{PICO_SDK_FETCH_FROM_GIT}) + message("Using PICO_SDK_FETCH_FROM_GIT from environment ('${PICO_SDK_FETCH_FROM_GIT}')") +endif () + +if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_PATH} AND (NOT PICO_SDK_FETCH_FROM_GIT_PATH)) + set(PICO_SDK_FETCH_FROM_GIT_PATH $ENV{PICO_SDK_FETCH_FROM_GIT_PATH}) + message("Using PICO_SDK_FETCH_FROM_GIT_PATH from environment ('${PICO_SDK_FETCH_FROM_GIT_PATH}')") +endif () + +if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_TAG} AND (NOT PICO_SDK_FETCH_FROM_GIT_TAG)) + set(PICO_SDK_FETCH_FROM_GIT_TAG $ENV{PICO_SDK_FETCH_FROM_GIT_TAG}) + message("Using PICO_SDK_FETCH_FROM_GIT_TAG from environment ('${PICO_SDK_FETCH_FROM_GIT_TAG}')") +endif () + +if (PICO_SDK_FETCH_FROM_GIT AND NOT PICO_SDK_FETCH_FROM_GIT_TAG) + set(PICO_SDK_FETCH_FROM_GIT_TAG "master") + message("Using master as default value for PICO_SDK_FETCH_FROM_GIT_TAG") +endif() + +set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the Raspberry Pi Pico SDK") +set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of SDK from git if not otherwise locatable") +set(PICO_SDK_FETCH_FROM_GIT_PATH "${PICO_SDK_FETCH_FROM_GIT_PATH}" CACHE FILEPATH "location to download SDK") +set(PICO_SDK_FETCH_FROM_GIT_TAG "${PICO_SDK_FETCH_FROM_GIT_TAG}" CACHE FILEPATH "release tag for SDK") + +if (NOT PICO_SDK_PATH) + if (PICO_SDK_FETCH_FROM_GIT) + include(FetchContent) + set(FETCHCONTENT_BASE_DIR_SAVE ${FETCHCONTENT_BASE_DIR}) + if (PICO_SDK_FETCH_FROM_GIT_PATH) + get_filename_component(FETCHCONTENT_BASE_DIR "${PICO_SDK_FETCH_FROM_GIT_PATH}" REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}") + endif () + FetchContent_Declare( + pico_sdk + GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk + GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG} + ) + + if (NOT pico_sdk) + message("Downloading Raspberry Pi Pico SDK") + # GIT_SUBMODULES_RECURSE was added in 3.17 + if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.17.0") + FetchContent_Populate( + pico_sdk + QUIET + GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk + GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG} + GIT_SUBMODULES_RECURSE FALSE + + SOURCE_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-src + BINARY_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-build + SUBBUILD_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-subbuild + ) + else () + FetchContent_Populate( + pico_sdk + QUIET + GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk + GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG} + + SOURCE_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-src + BINARY_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-build + SUBBUILD_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-subbuild + ) + endif () + + set(PICO_SDK_PATH ${pico_sdk_SOURCE_DIR}) + endif () + set(FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR_SAVE}) + else () + message(FATAL_ERROR + "SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git." + ) + endif () +endif () + +get_filename_component(PICO_SDK_PATH "${PICO_SDK_PATH}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}") +if (NOT EXISTS ${PICO_SDK_PATH}) + message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' not found") +endif () + +set(PICO_SDK_INIT_CMAKE_FILE ${PICO_SDK_PATH}/pico_sdk_init.cmake) +if (NOT EXISTS ${PICO_SDK_INIT_CMAKE_FILE}) + message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the Raspberry Pi Pico SDK") +endif () + +set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the Raspberry Pi Pico SDK" FORCE) + +include(${PICO_SDK_INIT_CMAKE_FILE})