From f36e54a5b5ec432ac17d6d149b66d871cafc5e8f Mon Sep 17 00:00:00 2001 From: PabloMK7 Date: Thu, 6 Mar 2025 15:34:50 +0100 Subject: [PATCH] Initial commit --- .gitignore | 2 + .gitmodules | 3 + LICENSE | 21 + Makefile | 18 + README.md | 15 + app/.gitignore | 8 + app/Makefile | 82 + app/buildtools/.buildconfig | 10 + app/buildtools/3ds/logo.bcma.lz | Bin 0 -> 8192 bytes app/buildtools/3ds/servefiles.py | 92 + app/buildtools/3ds/template.rsf | 286 +++ app/buildtools/README.md | 13 + app/buildtools/make_base | 757 ++++++ app/buildtools/wiiu/meta_template.xml | 9 + app/images/logo.bclim | Bin 0 -> 32808 bytes app/includes/3gx.h | 68 + app/includes/BCLIM.hpp | 74 + .../CTRPluginFramework/CTRPluginFramework.hpp | 7 + app/includes/CTRPluginFramework/Clock.hpp | 37 + app/includes/CTRPluginFramework/Color.hpp | 67 + app/includes/CTRPluginFramework/Rect.hpp | 143 ++ .../CTRPluginFramework/System/Lock.hpp | 54 + .../CTRPluginFramework/System/Mutex.hpp | 41 + app/includes/CTRPluginFramework/Time.hpp | 205 ++ app/includes/CTRPluginFramework/Vector.hpp | 124 + app/includes/Intellisense.hpp | 6 + app/includes/Logger.hpp | 47 + app/includes/Main.hpp | 5 + app/includes/csvc.h | 154 ++ app/includes/logo.h | 9 + app/includes/plgldr.h | 36 + app/resources/audio.cwav | Bin 0 -> 57560 bytes app/resources/banner.png | Bin 0 -> 30801 bytes app/resources/icon.pdn | Bin 0 -> 10389 bytes app/resources/icon.png | Bin 0 -> 3490 bytes app/resources/logo.bcma.lz | Bin 0 -> 8192 bytes app/sources/BCLIM.cpp | 150 ++ app/sources/CTRPluginFramework/Color.cpp | 158 ++ app/sources/CTRPluginFramework/Time.cpp | 26 + app/sources/Logger.cpp | 178 ++ app/sources/csvc.s | 122 + app/sources/logo.c | 2057 +++++++++++++++++ app/sources/main.cpp | 236 ++ app/sources/plgldr.c | 134 ++ images/logo_small.png | Bin 0 -> 15265 bytes plugin/.gitignore | 3 + plugin/3gx.ld | 202 ++ plugin/ArticProtocol | 1 + plugin/AzaharArticSetup.plgInfo | 27 + plugin/Makefile | 121 + plugin/images/logo.bclim | Bin 0 -> 32808 bytes plugin/includes/BCLIM.hpp | 74 + .../CTRPluginFramework/CTRPluginFramework.hpp | 7 + plugin/includes/CTRPluginFramework/Clock.hpp | 37 + plugin/includes/CTRPluginFramework/Color.hpp | 67 + plugin/includes/CTRPluginFramework/Rect.hpp | 143 ++ .../CTRPluginFramework/System/Lock.hpp | 54 + .../CTRPluginFramework/System/Mutex.hpp | 41 + plugin/includes/CTRPluginFramework/Time.hpp | 205 ++ plugin/includes/CTRPluginFramework/Vector.hpp | 124 + plugin/includes/Intellisense.hpp | 6 + plugin/includes/Main.hpp | 5 + plugin/includes/csvc.h | 154 ++ plugin/includes/logo.h | 9 + plugin/includes/nim_extheader.h | 134 ++ plugin/includes/plgldr.h | 79 + plugin/sendfile.py | 57 + plugin/sources/3gx_crt0.s | 86 + plugin/sources/ArticBaseFunctions.cpp | 906 ++++++++ plugin/sources/BCLIM.cpp | 150 ++ plugin/sources/CTRPluginFramework/Color.cpp | 158 ++ plugin/sources/CTRPluginFramework/Time.cpp | 26 + plugin/sources/csvc.s | 122 + plugin/sources/loaderCustom.cpp | 41 + plugin/sources/logo.c | 2057 +++++++++++++++++ plugin/sources/main.cpp | 340 +++ plugin/sources/plgldr.c | 347 +++ 77 files changed, 11237 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100644 app/.gitignore create mode 100644 app/Makefile create mode 100644 app/buildtools/.buildconfig create mode 100644 app/buildtools/3ds/logo.bcma.lz create mode 100644 app/buildtools/3ds/servefiles.py create mode 100644 app/buildtools/3ds/template.rsf create mode 100644 app/buildtools/README.md create mode 100644 app/buildtools/make_base create mode 100644 app/buildtools/wiiu/meta_template.xml create mode 100644 app/images/logo.bclim create mode 100644 app/includes/3gx.h create mode 100644 app/includes/BCLIM.hpp create mode 100644 app/includes/CTRPluginFramework/CTRPluginFramework.hpp create mode 100644 app/includes/CTRPluginFramework/Clock.hpp create mode 100644 app/includes/CTRPluginFramework/Color.hpp create mode 100644 app/includes/CTRPluginFramework/Rect.hpp create mode 100644 app/includes/CTRPluginFramework/System/Lock.hpp create mode 100644 app/includes/CTRPluginFramework/System/Mutex.hpp create mode 100644 app/includes/CTRPluginFramework/Time.hpp create mode 100644 app/includes/CTRPluginFramework/Vector.hpp create mode 100644 app/includes/Intellisense.hpp create mode 100644 app/includes/Logger.hpp create mode 100644 app/includes/Main.hpp create mode 100644 app/includes/csvc.h create mode 100644 app/includes/logo.h create mode 100644 app/includes/plgldr.h create mode 100644 app/resources/audio.cwav create mode 100644 app/resources/banner.png create mode 100644 app/resources/icon.pdn create mode 100644 app/resources/icon.png create mode 100644 app/resources/logo.bcma.lz create mode 100644 app/sources/BCLIM.cpp create mode 100644 app/sources/CTRPluginFramework/Color.cpp create mode 100644 app/sources/CTRPluginFramework/Time.cpp create mode 100644 app/sources/Logger.cpp create mode 100644 app/sources/csvc.s create mode 100644 app/sources/logo.c create mode 100644 app/sources/main.cpp create mode 100644 app/sources/plgldr.c create mode 100644 images/logo_small.png create mode 100644 plugin/.gitignore create mode 100644 plugin/3gx.ld create mode 160000 plugin/ArticProtocol create mode 100644 plugin/AzaharArticSetup.plgInfo create mode 100644 plugin/Makefile create mode 100644 plugin/images/logo.bclim create mode 100644 plugin/includes/BCLIM.hpp create mode 100644 plugin/includes/CTRPluginFramework/CTRPluginFramework.hpp create mode 100644 plugin/includes/CTRPluginFramework/Clock.hpp create mode 100644 plugin/includes/CTRPluginFramework/Color.hpp create mode 100644 plugin/includes/CTRPluginFramework/Rect.hpp create mode 100644 plugin/includes/CTRPluginFramework/System/Lock.hpp create mode 100644 plugin/includes/CTRPluginFramework/System/Mutex.hpp create mode 100644 plugin/includes/CTRPluginFramework/Time.hpp create mode 100644 plugin/includes/CTRPluginFramework/Vector.hpp create mode 100644 plugin/includes/Intellisense.hpp create mode 100644 plugin/includes/Main.hpp create mode 100644 plugin/includes/csvc.h create mode 100644 plugin/includes/logo.h create mode 100644 plugin/includes/nim_extheader.h create mode 100644 plugin/includes/plgldr.h create mode 100644 plugin/sendfile.py create mode 100644 plugin/sources/3gx_crt0.s create mode 100644 plugin/sources/ArticBaseFunctions.cpp create mode 100644 plugin/sources/BCLIM.cpp create mode 100644 plugin/sources/CTRPluginFramework/Color.cpp create mode 100644 plugin/sources/CTRPluginFramework/Time.cpp create mode 100644 plugin/sources/csvc.s create mode 100644 plugin/sources/loaderCustom.cpp create mode 100644 plugin/sources/logo.c create mode 100644 plugin/sources/main.cpp create mode 100644 plugin/sources/plgldr.c diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..15ee44d --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +images/logo.pdn +.vscode/ \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..152a33b --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "plugin/ArticProtocol"] + path = plugin/ArticProtocol + url = https://github.com/PabloMK7/ArticProtocol.git diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..6b4214e --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 PabloMK7 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..32cbfd5 --- /dev/null +++ b/Makefile @@ -0,0 +1,18 @@ +VERSION_MAJOR := 1 +VERSION_MINOR := 2 +VERSION_REVISION := 0 + +all: + mkdir -p plugin/build + sed -e 's/VERSION_MAJOR/$(VERSION_MAJOR)/' -e 's/VERSION_MINOR/$(VERSION_MINOR)/' -e 's/VERSION_REVISION/$(VERSION_REVISION)/' plugin/AzaharArticSetup.plgInfo > plugin/build/AzaharArticSetup.plgInfo + $(MAKE) -C plugin VERSION_MAJOR=$(VERSION_MAJOR) VERSION_MINOR=$(VERSION_MINOR) VERSION_REVISION=$(VERSION_REVISION) + bin2c -d app/includes/plugin.h -o app/sources/plugin.c plugin/AzaharArticSetup.3gx + $(MAKE) -C app VERSION_MAJOR=$(VERSION_MAJOR) VERSION_MINOR=$(VERSION_MINOR) VERSION_REVISION=$(VERSION_REVISION) + +clean: + $(MAKE) -C plugin clean + rm -f app/sources/plugin.c + rm -f app/includes/plugin.h + $(MAKE) -C app clean + +re: clean all \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..e475e4a --- /dev/null +++ b/README.md @@ -0,0 +1,15 @@ +# Azahar Artic Setup Tool + +## Description +**Azahar Artic Setup Tool** is a 3DS homebrew application that helps doing the initial setup of the [Azahar Emulator](https://github.com/azahar-emu/azahar) using your console. It broadcasts the System Settings application as well as the NIM sysmodule to be able to perform a system update. Furthermore, it copies your console unique data to be able to use online functionality. + +## Usage instructions +1) Download the `.cia` or `.3dsx` file from the [releases page](https://github.com/azahar-emu/ArticSetupTool/releases) and install it. +2) Run the Azahar Artic Setup Tool application. Press A to confirm you want to start it. +3) On the Azahar Emulator, go to `File -> Initial Setup` and enter the IP address displayed on your console. + +NOTE: A recent version of Luma3DS (v13.3.1 or newer) is requires to use Azahar Artic Setup Tool. You can get it [here](https://github.com/LumaTeam/Luma3DS/releases/latest). + +## License +See [LICENSE](LICENSE) + diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..1e68298 --- /dev/null +++ b/app/.gitignore @@ -0,0 +1,8 @@ +/build +*.3gx +.vscode/ +output/ +*.map + +includes/plugin.h +sources/plugin.c \ No newline at end of file diff --git a/app/Makefile b/app/Makefile new file mode 100644 index 0000000..1316898 --- /dev/null +++ b/app/Makefile @@ -0,0 +1,82 @@ +# TARGET # + + +TARGET := 3DS +LIBRARY := 0 + +ifeq ($(TARGET),$(filter $(TARGET),3DS WIIU)) + ifeq ($(strip $(DEVKITPRO)),) + $(error "Please set DEVKITPRO in your environment. export DEVKITPRO=devkitPro") + endif +endif + +# COMMON CONFIGURATION # + +NAME := Azahar Artic Setup + +BUILD_DIR := build +OUTPUT_DIR := output +SOURCE_DIRS := sources +INCLUDE_DIRS := $(SOURCE_DIRS) includes + +EXTRA_OUTPUT_FILES := + +LIBRARY_DIRS := $(PORTLIBS) $(CTRULIB) $(DEVKITPRO)/libcwav $(DEVKITPRO)/libncsnd +LIBRARIES := ctru + +VERSION_MAJOR := 1 +VERSION_MINOR := 0 +VERSION_MICRO := 0 + +BUILD_FLAGS := -march=armv6k -mtune=mpcore -mfloat-abi=hard +BUILD_FLAGS_CC := -g -Wall -Wno-strict-aliasing -O3 -mword-relocations \ + -fomit-frame-pointer -ffast-math $(ARCH) $(INCLUDE) -D__3DS__ $(BUILD_FLAGS) \ + -DVERSION_MAJOR=${VERSION_MAJOR} \ + -DVERSION_MINOR=${VERSION_MINOR} \ + -DVERSION_REVISION=${VERSION_MICRO} + +BUILD_FLAGS_CXX := $(BUILD_FLAGS_CC) $(COMMON_FLAGS) -fno-rtti -fno-exceptions -std=gnu++20 +RUN_FLAGS := + +# 3DS/Wii U CONFIGURATION # + +ifeq ($(TARGET),$(filter $(TARGET),3DS WIIU)) + TITLE := Azahar Artic Setup Tool + DESCRIPTION := Setup tool for Azahar Emulator + AUTHOR := PabloMK7 +endif + +# 3DS CONFIGURATION # + +ifeq ($(TARGET),3DS) + LIBRARY_DIRS += $(DEVKITPRO)/libctru $(DEVKITPRO)/portlibs/3ds/ + LIBRARIES += ctru + + PRODUCT_CODE := CTR-P-AAST + UNIQUE_ID := 0xAE5E7 + + CATEGORY := Application + USE_ON_SD := true + + MEMORY_TYPE := Application + SYSTEM_MODE := 64MB + SYSTEM_MODE_EXT := Legacy + CPU_SPEED := 268MHz + ENABLE_L2_CACHE := true + + ICON_FLAGS := --flags visible,recordusage + + BANNER_AUDIO := resources/audio.cwav + + BANNER_IMAGE := resources/banner.png + + ICON := resources/icon.png + +endif + +# INTERNAL # + +include buildtools/make_base + +re : clean all +.PHONY: re \ No newline at end of file diff --git a/app/buildtools/.buildconfig b/app/buildtools/.buildconfig new file mode 100644 index 0000000..116b101 --- /dev/null +++ b/app/buildtools/.buildconfig @@ -0,0 +1,10 @@ +[default] +name=Default +runtime=host +config-opts= +run-opts= +prefix=/home/steven/.cache/gnome-builder/install/buildtools/host +app-id= +postbuild= +prebuild= +default=true diff --git a/app/buildtools/3ds/logo.bcma.lz b/app/buildtools/3ds/logo.bcma.lz new file mode 100644 index 0000000000000000000000000000000000000000..dd9db8cda2c5fa0ba767e5f25dda002579af78b8 GIT binary patch literal 8192 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 D6|7Yq literal 0 HcmV?d00001 diff --git a/app/buildtools/3ds/servefiles.py b/app/buildtools/3ds/servefiles.py new file mode 100644 index 0000000..549ef3a --- /dev/null +++ b/app/buildtools/3ds/servefiles.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python +# coding: utf-8 -*- + +import os +import socket +import struct +import sys +import threading +import time +import urllib + +try: + from SimpleHTTPServer import SimpleHTTPRequestHandler + from SocketServer import TCPServer + from urlparse import urljoin + from urllib import pathname2url, quote +except ImportError: + from http.server import SimpleHTTPRequestHandler + from socketserver import TCPServer + from urllib.parse import urljoin, quote + from urllib.request import pathname2url + +if len(sys.argv) < 3 or len(sys.argv) > 5: + print('Usage: ' + sys.argv[0] + ' [host ip] [host port]') + sys.exit(1) + +accepted_extension = ('.cia', '.tik', '.cetk') +target_ip = sys.argv[1] +target_path = sys.argv[2] +hostPort = 8080 # Default value + +if not os.path.exists(target_path): + print(target_path + ': No such file or directory.') + sys.exit(1) + +if len(sys.argv) >= 4: + hostIp = sys.argv[3] + if len(sys.argv) == 5: + hostPort = int(sys.argv[4]) +else: + print('Detecting host IP...') + hostIp = [(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1] + +print('Preparing data...') +baseUrl = hostIp + ':' + str(hostPort) + '/' + +if os.path.isfile(target_path): + if target_path.endswith(accepted_extension): + file_list_payload = baseUrl + quote(os.path.basename(target_path)) + directory = os.path.dirname(target_path) # get file directory + else: + print('Unsupported file extension. Supported extensions are: ' + accepted_extension) + sys.exit(1) + +else: + directory = target_path # it's a directory + file_list_payload = '' # init the payload before adding lines + for file in [file for file in next(os.walk(target_path))[2] if file.endswith(accepted_extension)]: + file_list_payload += baseUrl + quote(file) + '\n' + +if len(file_list_payload) == 0: + print('No files to serve.') + sys.exit(1) + +file_list_payloadBytes = file_list_payload.encode('ascii') + +if directory and directory != '.': # doesn't need to move if it's already the current working directory + os.chdir(directory) # set working directory to the right folder to be able to serve files + +print('\nURLs:') +print(file_list_payload + '\n') + +print('Opening HTTP server on port ' + str(hostPort)) +server = TCPServer(('', hostPort), SimpleHTTPRequestHandler) +thread = threading.Thread(target=server.serve_forever) +thread.start() + +try: + print('Sending URL(s) to ' + target_ip + ' on port 5000...') + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.connect((target_ip, 5000)) + sock.sendall(struct.pack('!L', len(file_list_payloadBytes)) + file_list_payloadBytes) + while len(sock.recv(1)) < 1: + time.sleep(0.05) + sock.close() +except Exception as e: + print('An error occurred: ' + str(e)) + server.shutdown() + sys.exit(1) + +print('Shutting down HTTP server...') +server.shutdown() diff --git a/app/buildtools/3ds/template.rsf b/app/buildtools/3ds/template.rsf new file mode 100644 index 0000000..e89849d --- /dev/null +++ b/app/buildtools/3ds/template.rsf @@ -0,0 +1,286 @@ +BasicInfo: + Title : $(APP_TITLE) + ProductCode : $(APP_PRODUCT_CODE) + Logo : Homebrew + +RomFs: + RootPath: $(APP_ROMFS) + +TitleInfo: + Category : $(APP_CATEGORY) + UniqueId : $(APP_UNIQUE_ID) + +Option: + UseOnSD : $(APP_USE_ON_SD) # true if App is to be installed to SD + FreeProductCode : true # Removes limitations on ProductCode + MediaFootPadding : false # If true CCI files are created with padding + EnableCrypt : $(APP_ENCRYPTED) # Enables encryption for NCCH and CIA + EnableCompress : true # Compresses where applicable (currently only exefs:/.code) + +AccessControlInfo: + CoreVersion : 2 + + # Exheader Format Version + DescVersion : 2 + + # Minimum Required Kernel Version (below is for 4.5.0) + ReleaseKernelMajor : "02" + ReleaseKernelMinor : "33" + + # ExtData + UseExtSaveData : false # enables ExtData + #ExtSaveDataId : 0x300 # only set this when the ID is different to the UniqueId + + # FS:USER Archive Access Permissions + # Uncomment as required + FileSystemAccess: + - CategorySystemApplication + - CategoryHardwareCheck + - CategoryFileSystemTool + - Debug + - TwlCardBackup + - TwlNandData + - Boss + - DirectSdmc + - Core + - CtrNandRo + - CtrNandRw + - CtrNandRoWrite + - CategorySystemSettings + - CardBoard + - ExportImportIvs + - DirectSdmcWrite + - SwitchCleanup + - SaveDataMove + - Shop + - Shell + - CategoryHomeMenu + - SeedDB + IoAccessControl: + - FsMountNand + - FsMountNandRoWrite + - FsMountTwln + - FsMountWnand + - FsMountCardSpi + - UseSdif3 + - CreateSeed + - UseCardSpi + + # Process Settings + MemoryType : $(APP_MEMORY_TYPE) # Application/System/Base + SystemMode : $(APP_SYSTEM_MODE) # 64MB(Default)/96MB/80MB/72MB/32MB + IdealProcessor : 0 + AffinityMask : 1 + Priority : 16 + MaxCpu : 0x9E # Default + HandleTableSize : 0x200 + DisableDebug : false + EnableForceDebug : false + CanWriteSharedPage : true + CanUsePrivilegedPriority : false + CanUseNonAlphabetAndNumber : true + PermitMainFunctionArgument : true + CanShareDeviceMemory : true + RunnableOnSleep : false + SpecialMemoryArrange : true + + # New3DS Exclusive Process Settings + SystemModeExt : $(APP_SYSTEM_MODE_EXT) # Legacy(Default)/124MB/178MB Legacy:Use Old3DS SystemMode + CpuSpeed : $(APP_CPU_SPEED) # 268MHz(Default)/804MHz + EnableL2Cache : $(APP_ENABLE_L2_CACHE) # false(default)/true + CanAccessCore2 : true + + # Virtual Address Mappings + IORegisterMapping: + - 1ff00000-1ff7ffff # DSP memory + MemoryMapping: + - 1f000000-1f5fffff:r # VRAM + + # Accessible SVCs, : + SystemCallAccess: + ControlMemory: 1 + QueryMemory: 2 + ExitProcess: 3 + GetProcessAffinityMask: 4 + SetProcessAffinityMask: 5 + GetProcessIdealProcessor: 6 + SetProcessIdealProcessor: 7 + CreateThread: 8 + ExitThread: 9 + SleepThread: 10 + GetThreadPriority: 11 + SetThreadPriority: 12 + GetThreadAffinityMask: 13 + SetThreadAffinityMask: 14 + GetThreadIdealProcessor: 15 + SetThreadIdealProcessor: 16 + GetCurrentProcessorNumber: 17 + Run: 18 + CreateMutex: 19 + ReleaseMutex: 20 + CreateSemaphore: 21 + ReleaseSemaphore: 22 + CreateEvent: 23 + SignalEvent: 24 + ClearEvent: 25 + CreateTimer: 26 + SetTimer: 27 + CancelTimer: 28 + ClearTimer: 29 + CreateMemoryBlock: 30 + MapMemoryBlock: 31 + UnmapMemoryBlock: 32 + CreateAddressArbiter: 33 + ArbitrateAddress: 34 + CloseHandle: 35 + WaitSynchronization1: 36 + WaitSynchronizationN: 37 + SignalAndWait: 38 + DuplicateHandle: 39 + GetSystemTick: 40 + GetHandleInfo: 41 + GetSystemInfo: 42 + GetProcessInfo: 43 + GetThreadInfo: 44 + ConnectToPort: 45 + SendSyncRequest1: 46 + SendSyncRequest2: 47 + SendSyncRequest3: 48 + SendSyncRequest4: 49 + SendSyncRequest: 50 + OpenProcess: 51 + OpenThread: 52 + GetProcessId: 53 + GetProcessIdOfThread: 54 + GetThreadId: 55 + GetResourceLimit: 56 + GetResourceLimitLimitValues: 57 + GetResourceLimitCurrentValues: 58 + GetThreadContext: 59 + Break: 60 + OutputDebugString: 61 + ControlPerformanceCounter: 62 + CreatePort: 71 + CreateSessionToPort: 72 + CreateSession: 73 + AcceptSession: 74 + ReplyAndReceive1: 75 + ReplyAndReceive2: 76 + ReplyAndReceive3: 77 + ReplyAndReceive4: 78 + ReplyAndReceive: 79 + BindInterrupt: 80 + UnbindInterrupt: 81 + InvalidateProcessDataCache: 82 + StoreProcessDataCache: 83 + FlushProcessDataCache: 84 + StartInterProcessDma: 85 + StopDma: 86 + GetDmaState: 87 + RestartDma: 88 + DebugActiveProcess: 96 + BreakDebugProcess: 97 + TerminateDebugProcess: 98 + GetProcessDebugEvent: 99 + ContinueDebugEvent: 100 + GetProcessList: 101 + GetThreadList: 102 + GetDebugThreadContext: 103 + SetDebugThreadContext: 104 + QueryDebugProcessMemory: 105 + ReadProcessMemory: 106 + WriteProcessMemory: 107 + SetHardwareBreakPoint: 108 + GetDebugThreadParam: 109 + ControlProcessMemory: 112 + MapProcessMemory: 113 + UnmapProcessMemory: 114 + CreateCodeSet: 115 + CreateProcess: 117 + TerminateProcess: 118 + SetProcessResourceLimits: 119 + CreateResourceLimit: 120 + SetResourceLimitValues: 121 + AddCodeSegment: 122 + Backdoor: 123 + KernelSetState: 124 + QueryProcessMemory: 125 + + # Service List + # Maximum 34 services (32 if firmware is prior to 9.6.0) + ServiceAccessControl: + - APT:U + - ac:u + - am:net + - boss:U + - cam:u + - cecd:u + - cfg:nor + - cfg:u + - csnd:SND + - dsp::DSP + - frd:u + - fs:USER + - gsp::Gpu + - gsp::Lcd + - hid:USER + - http:C + - ir:rst + - ir:u + - ir:USER + - mic:u + - mcu::HWC + - ndm:u + - news:s + - nwm::EXT + - nwm::UDS + - ptm:sysm + - ptm:u + - pxi:dev + - soc:U + - ssl:C + - y2r:u + + +SystemControlInfo: + SaveDataSize: 0KB # Change if the app uses savedata + RemasterVersion: $(APP_VERSION_MAJOR) + StackSize: 0x40000 + + # Modules that run services listed above should be included below + # Maximum 48 dependencies + # : + Dependency: + ac: 0x0004013000002402 + #act: 0x0004013000003802 + am: 0x0004013000001502 + boss: 0x0004013000003402 + camera: 0x0004013000001602 + cecd: 0x0004013000002602 + cfg: 0x0004013000001702 + codec: 0x0004013000001802 + csnd: 0x0004013000002702 + dlp: 0x0004013000002802 + dsp: 0x0004013000001a02 + friends: 0x0004013000003202 + gpio: 0x0004013000001b02 + gsp: 0x0004013000001c02 + hid: 0x0004013000001d02 + http: 0x0004013000002902 + i2c: 0x0004013000001e02 + ir: 0x0004013000003302 + mcu: 0x0004013000001f02 + mic: 0x0004013000002002 + ndm: 0x0004013000002b02 + news: 0x0004013000003502 + #nfc: 0x0004013000004002 + nim: 0x0004013000002c02 + nwm: 0x0004013000002d02 + pdn: 0x0004013000002102 + ps: 0x0004013000003102 + ptm: 0x0004013000002202 + #qtm: 0x0004013020004202 + ro: 0x0004013000003702 + socket: 0x0004013000002e02 + spi: 0x0004013000002302 + ssl: 0x0004013000002f02 diff --git a/app/buildtools/README.md b/app/buildtools/README.md new file mode 100644 index 0000000..f6589ee --- /dev/null +++ b/app/buildtools/README.md @@ -0,0 +1,13 @@ +# buildtools + +Common build tools for C/C++ projects. Supports PC and 3DS targets. + +Dependencies: + * [makerom](https://github.com/profi200/Project_CTR/tree/master/makerom/) - Building 3DS/CIA files. + * [bannertool](https://github.com/Steveice10/bannertool/) - Building 3DS/CIA files. + * [citra](https://github.com/citra-emu/citra/) - Testing 3DS/CIA builds on a PC. + * zip - Zipping up output files. + * xxd - Embedding binary files in executables. + * python - Installing CIA builds to a 3DS over the network. + +Credit for 3DS homebrew logo goes to [PabloMK7](http://gbatemp.net/members/pablomk7.345712/). diff --git a/app/buildtools/make_base b/app/buildtools/make_base new file mode 100644 index 0000000..b16e59c --- /dev/null +++ b/app/buildtools/make_base @@ -0,0 +1,757 @@ +# Make Variables +# +# TARGET: Optional; Platform to build for. +# - Supported values: NATIVE, NATIVE32, NATIVE64, WIN32, WIN64, MAC32, MAC64, LINUX32, LINUX64, 3DS, WIIU, SWITCH +# - Default value: NATIVE +# LIBRARY: Optional; Whether to output a library. +# - Supported values: 0, 1 +# - Default value: 0 +# +# All: +# - NAME: Project name. +# - INCLUDE_DIRS: Directories containing include headers. +# - SOURCE_DIRS: Directories containing source files to compile. +# - BUILD_DIR: Directory to store build files in. +# - OUTPUT_DIR: Directory to output the final results to. +# - LIBRARY_DIRS: Optional; Directories containing libraries to compile against. +# - LIBRARIES: Optional; Libraries to compile against. +# - EXTRA_OUTPUT_FILES: Optional; Extra files to copy to the output directory. +# - BUILD_FLAGS: Optional; Shared build flags. +# - BUILD_FLAGS_CC: Optional; C build flags. +# - BUILD_FLAGS_CXX: Optional; C++ build flags. +# - RUN_FLAGS: Optional; Flags to pass when running output executables. +# - VERSION_MAJOR: Optional; Major version number. +# - Default value: 0 +# - VERSION_MINOR: Optional; Minor version number. +# - Default value: 0 +# - VERSION_MICRO: Optional; Micro version number. +# - Default value: 0 +# +# 3DS/Wii U/Switch: +# - TITLE: Optional; Formal application title, used in metadata. +# - Default value: NAME stripped of spaces. +# - AUTHOR: Optional; Application author. +# - Default value: "Unknown" +# - REMOTE_IP: Optional; IP to send executable to when running on hardware. Intended to be set in command line. +# - Default value: 127.0.0.1 +# +# 3DS/Wii U: +# - DESCRIPTION: Optional; Application description. +# - Default value: "No description." +# +# 3DS: +# - PRODUCT_CODE: CIA/3DS product code. +# - UNIQUE_ID: CIA/3DS unique ID. +# - BANNER_AUDIO: Audio file to use in the CIA/3DS banner. +# - Supported file types: WAV, CWAV +# - BANNER_IMAGE: Graphics to use in the CIA/3DS banner. +# - Supported file types: 256x128 PNG, CGFX +# - ICON: Application icon. +# - Supported file types: 48x48 PNG +# - Category: Optional; CIA/3DS category. +# - Supported values: Application, SystemApplication, Applet, Firmware, Base, DlpChild, Demo, Contents, SystemContents, SharedContents, AddOnContents, Patch, AutoUpdateContents +# - Default value: Application +# - USE_ON_SD: Optional; Whether the CIA/3DS should be installed to the SD card. +# - Supported values: true, false +# - Default value: true +# - MEMORY_TYPE: Optional; CIA/3DS application memory layout. +# - Supported values: Application, System, Base +# - Default value: Application +# - SYSTEM_MODE: Optional; CIA/3DS legacy system mode. +# - Supported values: 32MB, 64MB, 72MB, 80MB, 96MB +# - Default value: 64MB +# - SYSTEM_MODE_EXT: Optional; CIA/3DS extended system mode. +# - Supported values: Legacy, 124MB, 178MB +# - Default value: Legacy +# - CPU_MODE: Optional; CIA/3DS CPU frequency. 804MHz is N3DS-only. +# - Supported values: 268MHz, 804MHz +# - Default value: 268MHz +# - ENABLE_L2_CACHE: Optional; Whether the CIA/3DS should use the N3DS L2 cache. +# - Supported values: true, false +# - Default value: false +# - ICON_FLAGS: Optional; Flags to pass to bannertool when making an SMDH icon. +# - ROMFS_DIR: Optional; Directory containing RomFS files. +# - LOGO: Optional; Logo animation to use when launching the CIA/3DS. +# - Supported file types: BCMA.LZ +# +# Wii U: +# - ICON: Application icon. +# - Supported file types: 256x96 PNG +# - LONG_DESCRIPTION: Optional; Long version of the description field. +# - Default value: Value of DESCRIPTION. +# +# Switch: +# - TITLE_ID: Optional; Application title ID. +# - ICON: Optional; Application icon. +# - Supported file types: 256x256 JPEG + +# PROLOGUE # + +TARGET ?= NATIVE +LIBRARY ?= 0 + +ALL_PC_TARGETS := WIN32 WIN64 MAC32 MAC64 LINUX32 LINUX64 +ALL_SPECIFIC_TARGETS := $(ALL_PC_TARGETS) 3DS WIIU SWITCH +ALL_TARGETS := NATIVE NATIVE32 NATIVE64 $(ALL_SPECIFIC_TARGETS) + +TARGETS := + +ifneq (1,$(words $(TARGET))) + TARGETS := $(TARGET) +else ifeq ($(TARGET),ALL) + TARGETS := $(ALL_SPECIFIC_TARGETS) +else ifeq ($(TARGET),PC) + TARGETS := $(ALL_PC_TARGETS) +endif + +ifneq ($(TARGETS),) + +.PHONY: all clean +all: + @$(foreach target,$(TARGETS),make --no-print-directory TARGET=$(target);) + +else + +ifneq ($(MAKECMDGOALS),clean) + $(info Building for $(TARGET)...) +endif + +ifeq ($(TARGET),$(filter $(TARGET),3DS WIIU SWITCH)) + ifeq ($(strip $(DEVKITPRO)),) + $(error "Please set DEVKITPRO in your environment. export DEVKITPRO=devkitPro") + endif +endif + +# TOOLS # + +BUILDTOOLS_DIR := $(dir $(lastword $(MAKEFILE_LIST))) + +define createdirrule +$(1): | $(dir $(1)) + +ifndef $(dir $(1))_DIRECTORY_RULE_IS_DEFINED +$(dir $(1)): + @mkdir -p $$@ + +$(dir $(1))_DIRECTORY_RULE_IS_DEFINED := 1 +endif +endef + +rwildcard=$(wildcard $1/$2) $(foreach d,$(wildcard $1/*),$(call rwildcard,$d,$2)) + +# INITIAL COMMON SETUP # + +EMPTY := +SPACE := $(EMPTY) $(EMPTY) +STRIPPED_NAME := $(subst $(SPACE),,$(NAME)) + +ifeq ($(OS),Windows_NT) + HOST_OS := windows + ifeq ($(PROCESSOR_ARCHITECTURE),AMD64) + HOST_ARCH := x86_64 + else + HOST_ARCH := i686 + endif +else + UNAME_S := $(shell uname -s) + ifeq ($(UNAME_S),Darwin) + HOST_OS := mac + else ifeq ($(UNAME_S),Linux) + HOST_OS := linux + else + $(error "Unsupported host OS.") + endif + + UNAME_M := $(shell uname -m) + ifeq ($(UNAME_M),$(filter $(UNAME_M),x86_64 amd64)) + HOST_ARCH := x86_64 + else ifeq ($(UNAME_M),$(filter $(UNAME_M),i386 i686)) + HOST_ARCH := i686 + else + $(error "Unsupported host architecture.") + endif +endif + +ifeq ($(TARGET),NATIVE) + TARGET_OS := $(HOST_OS) + TARGET_ARCH := $(HOST_ARCH) +else ifeq ($(TARGET),NATIVE32) + TARGET_OS := $(HOST_OS) + TARGET_ARCH := i686 +else ifeq ($(TARGET),NATIVE64) + TARGET_OS := $(HOST_OS) + TARGET_ARCH := x86_64 +else ifeq ($(TARGET),WIN32) + TARGET_OS := windows + TARGET_ARCH := i686 +else ifeq ($(TARGET),WIN64) + TARGET_OS := windows + TARGET_ARCH := x86_64 +else ifeq ($(TARGET),LINUX32) + TARGET_OS := linux + TARGET_ARCH := i686 +else ifeq ($(TARGET),LINUX64) + TARGET_OS := linux + TARGET_ARCH := x86_64 +else ifeq ($(TARGET),MAC32) + TARGET_OS := mac + TARGET_ARCH := i686 +else ifeq ($(TARGET),MAC64) + TARGET_OS := mac + TARGET_ARCH := x86_64 +else ifeq ($(TARGET),3DS) + TARGET_OS := 3ds + TARGET_ARCH := arm +else ifeq ($(TARGET),WIIU) + TARGET_OS := wiiu + TARGET_ARCH := ppc +else ifeq ($(TARGET),SWITCH) + TARGET_OS := switch + TARGET_ARCH := aarch64 +else + $(error "Unknown target. Supported targets: $(ALL_TARGETS)") +endif + +TARGET_BUILD_DIR := $(BUILD_DIR)/$(TARGET_OS)-$(TARGET_ARCH) +TARGET_OUTPUT_DIR := $(OUTPUT_DIR)/$(TARGET_OS)-$(TARGET_ARCH) + +BUILT_FILTER := $(patsubst %.bin,$(TARGET_BUILD_DIR)/%.bin.o,$(BUILD_FILTER)) \ + $(patsubst %.c,$(TARGET_BUILD_DIR)/%.o,$(BUILD_FILTER)) \ + $(patsubst %.cpp,$(TARGET_BUILD_DIR)/%.o,$(BUILD_FILTER)) \ + $(patsubst %.s,$(TARGET_BUILD_DIR)/%.o,$(BUILD_FILTER)) + +OBJECT_FILES := $(foreach dir,$(SOURCE_DIRS), \ + $(patsubst %.bin,$(TARGET_BUILD_DIR)/%.bin.o,$(call rwildcard,$(dir),*.bin)) \ + $(patsubst %.c,$(TARGET_BUILD_DIR)/%.o,$(call rwildcard,$(dir),*.c)) \ + $(patsubst %.cpp,$(TARGET_BUILD_DIR)/%.o,$(call rwildcard,$(dir),*.cpp)) \ + $(patsubst %.s,$(TARGET_BUILD_DIR)/%.o,$(call rwildcard,$(dir),*.s)) \ + ) + +OBJECT_FILES := $(filter-out $(BUILT_FILTER),$(OBJECT_FILES)) + +OUTPUT_ZIP_FILE ?= $(OUTPUT_DIR)/$(STRIPPED_NAME).zip + +ifeq ($(strip $(VERSION_MAJOR)),) + VERSION_MAJOR := 0 +endif + +ifeq ($(strip $(VERSION_MINOR)),) + VERSION_MINOR := 0 +endif + +ifeq ($(strip $(VERSION_MICRO)),) + VERSION_MICRO := 0 +endif + +LD_FLAGS := $(patsubst %,-L%/lib,$(LIBRARY_DIRS)) $(patsubst %,-l%,$(LIBRARIES)) -Wl,-Map,MyApp.map +COMMON_CC_FLAGS := $(sort $(foreach dir,$(SOURCE_DIRS),$(patsubst %,-I$(TARGET_BUILD_DIR)/%,$(dir $(call rwildcard,$(dir),*))))) $(patsubst %,-I%,$(INCLUDE_DIRS)) $(patsubst %,-I%/include,$(LIBRARY_DIRS)) -g -Wall -DVERSION_MAJOR=$(VERSION_MAJOR) -DVERSION_MINOR=$(VERSION_MINOR) -DVERSION_MICRO=$(VERSION_MICRO) $(BUILD_FLAGS) +COMMON_CXX_FLAGS := + +ifeq ($(findstring -O,$(BUILD_FLAGS)),) + COMMON_CC_FLAGS += -O2 +endif + +# COMMON LIBRARY SETUP # + +ifeq ($(LIBRARY),1) + STRIPPED_NAME := lib$(STRIPPED_NAME) + EXTRA_OUTPUT_FILES += $(INCLUDE_DIRS) +endif + +# TARGET SETUP # + +REMOTE_IP ?= 127.0.0.1 # User-defined + +TITLE ?= $(NAME) +AUTHOR ?= "Unknown" +DESCRIPTION ?= "No description." +LONG_DESCRIPTION ?= $(DESCRIPTION) + +ifeq ($(TARGET_OS),windows) + ifeq ($(HOST_OS),windows) + AR := ar + AS := as + CC := gcc + CXX := g++ + else ifeq ($(TARGET_ARCH),i686) + AR := i686-w64-mingw32-ar + AS := i686-w64-mingw32-as + CC := i686-w64-mingw32-gcc + CXX := i686-w64-mingw32-g++ + else ifeq ($(TARGET_ARCH),x86_64) + AR := x86_64-w64-mingw32-ar + AS := x86_64-w64-mingw32-as + CC := x86_64-w64-mingw32-gcc + CXX := x86_64-w64-mingw32-g++ + endif + + ifeq ($(TARGET_ARCH),i686) + COMMON_CC_FLAGS += -m32 + else ifeq ($(TARGET_ARCH),x86_64) + COMMON_CC_FLAGS += -m64 + endif + + LD_FLAGS += -static-libstdc++ -static-libgcc -static + + ifeq ($(LIBRARY),1) + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).a $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).dll + COMMON_CC_FLAGS += -fPIC + else + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME).exe + endif +else ifeq ($(TARGET_OS),mac) + ifeq ($(HOST_OS),mac) + AR := ar + AS := as + CC := gcc + CXX := g++ + else ifeq ($(TARGET_ARCH),i686) + AR := i386-apple-darwin15-ar + AS := i386-apple-darwin15-as + CC := i386-apple-darwin15-gcc + CXX := i386-apple-darwin15-g++ + else ifeq ($(TARGET_ARCH),x86_64) + AR := x86_64-apple-darwin15-ar + AS := x86_64-apple-darwin15-as + CC := x86_64-apple-darwin15-gcc + CXX := x86_64-apple-darwin15-g++ + endif + + ifeq ($(TARGET_ARCH),i686) + COMMON_CC_FLAGS += -m32 + else ifeq ($(TARGET_ARCH),x86_64) + COMMON_CC_FLAGS += -m64 + endif + + ifeq ($(LIBRARY),1) + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).a $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).so $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).dylib + COMMON_CC_FLAGS += -fPIC + else + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME) + endif +else ifeq ($(TARGET_OS),linux) + ifeq ($(HOST_OS),linux) + AR := ar + AS := as + CC := gcc + CXX := g++ + else ifeq ($(TARGET_ARCH),i686) + AR := i686-pc-linux-gnu-ar + AS := i686-pc-linux-gnu-as + CC := i686-pc-linux-gnu-gcc + CXX := i686-pc-linux-gnu-g++ + else ifeq ($(TARGET_ARCH),x86_64) + AR := x86_64-pc-linux-gnu-ar + AS := x86_64-pc-linux-gnu-as + CC := x86_64-pc-linux-gnu-gcc + CXX := x86_64-pc-linux-gnu-g++ + endif + + ifeq ($(TARGET_ARCH),i686) + COMMON_CC_FLAGS += -m32 + else ifeq ($(TARGET_ARCH),x86_64) + COMMON_CC_FLAGS += -m64 + endif + + ifeq ($(LIBRARY),1) + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).a $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).so + COMMON_CC_FLAGS += -fPIC + else + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME) + endif +else ifeq ($(TARGET_OS),3ds) + BUILT_FILTER := $(patsubst %.v.pica,$(TARGET_BUILD_DIR)/%.shbin.o,$(BUILD_FILTER)) \ + $(patsubst %.shlist,$(TARGET_BUILD_DIR)/%.shbin.o,$(BUILD_FILTER)) \ + + OBJECT_FILES := $(foreach dir,$(SOURCE_DIRS), \ + $(patsubst %.v.pica,$(TARGET_BUILD_DIR)/%.shbin.o,$(call rwildcard,$(dir),*.v.pica)) \ + $(patsubst %.shlist,$(TARGET_BUILD_DIR)/%.shbin.o,$(call rwildcard,$(dir),*.shlist)) \ + ) $(OBJECT_FILES) + + OBJECT_FILES := $(filter-out $(BUILT_FILTER),$(OBJECT_FILES)) + + DEVKITARM := $(DEVKITPRO)/devkitARM + + AR := $(DEVKITARM)/bin/arm-none-eabi-ar + AS := $(DEVKITARM)/bin/arm-none-eabi-as + CC := $(DEVKITARM)/bin/arm-none-eabi-gcc + CXX := $(DEVKITARM)/bin/arm-none-eabi-g++ + + ifeq ($(LIBRARY),1) + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).a + else + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME).elf $(TARGET_OUTPUT_DIR)/3ds/$(STRIPPED_NAME)/$(STRIPPED_NAME).3dsx $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME).3ds $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME).cia + endif + + LD_FLAGS += -specs=3dsx.specs + COMMON_CC_FLAGS += -mword-relocations -ffast-math -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft -D__3DS__ + + SERVEFILES := python $(BUILDTOOLS_DIR)/3ds/servefiles.py + + CATEGORY ?= Application + USE_ON_SD ?= true + MEMORY_TYPE ?= Application + SYSTEM_MODE ?= 64MB + SYSTEM_MODE_EXT ?= Legacy + CPU_SPEED ?= 268MHz + ENABLE_L2_CACHE ?= false + + _3DSXTOOL_FLAGS := + COMMON_MAKEROM_FLAGS := -rsf $(BUILDTOOLS_DIR)/3ds/template.rsf -target t -exefslogo -icon $(TARGET_BUILD_DIR)/icon.icn -banner $(TARGET_BUILD_DIR)/banner.bnr -major $(VERSION_MAJOR) -minor $(VERSION_MINOR) -micro $(VERSION_MICRO) -DAPP_TITLE="$(TITLE)" -DAPP_PRODUCT_CODE="$(PRODUCT_CODE)" -DAPP_UNIQUE_ID="$(UNIQUE_ID)" -DAPP_SYSTEM_MODE="$(SYSTEM_MODE)" -DAPP_SYSTEM_MODE_EXT="$(SYSTEM_MODE_EXT)" -DAPP_CATEGORY="$(CATEGORY)" -DAPP_USE_ON_SD="$(USE_ON_SD)" -DAPP_MEMORY_TYPE="$(MEMORY_TYPE)" -DAPP_CPU_SPEED="$(CPU_SPEED)" -DAPP_ENABLE_L2_CACHE="$(ENABLE_L2_CACHE)" -DAPP_VERSION_MAJOR="$(VERSION_MAJOR)" + + ifneq ("$(wildcard $(ROMFS_DIR))","") + _3DSXTOOL_FLAGS += --romfs=$(ROMFS_DIR) + COMMON_MAKEROM_FLAGS += -DAPP_ROMFS="$(ROMFS_DIR)" + endif + + ifneq ("$(wildcard $(LOGO))","") + COMMON_MAKEROM_FLAGS += -logo "$(LOGO)" + else ifneq ($(LOGO),plain) + COMMON_MAKEROM_FLAGS += -logo "$(BUILDTOOLS_DIR)/3ds/logo.bcma.lz" + endif + + ifeq ($(suffix $(BANNER_IMAGE)),.cgfx) + BANNER_IMAGE_ARG := -ci + else + BANNER_IMAGE_ARG := -i + endif + + ifeq ($(suffix $(BANNER_AUDIO)),.cwav) + BANNER_AUDIO_ARG := -ca + else + BANNER_AUDIO_ARG := -a + endif +else ifeq ($(TARGET_OS),wiiu) + DEVKITPPC := $(DEVKITPRO)/devkitPPC + + AR := $(DEVKITPPC)/bin/powerpc-eabi-ar + AS := $(DEVKITPPC)/bin/powerpc-eabi-as + CC := $(DEVKITPPC)/bin/powerpc-eabi-gcc + CXX := $(DEVKITPPC)/bin/powerpc-eabi-g++ + + ifeq ($(LIBRARY),1) + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).a + else + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/$(STRIPPED_NAME).elf $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/icon.png + endif + + LD_FLAGS += -Wl,-d,--gc-sections + COMMON_CC_FLAGS += -mwup -mcpu=750 -meabi -mhard-float -ffast-math -DESPRESSO -DWIIU +else ifeq ($(TARGET_OS),switch) + DEVKITA64 := $(DEVKITPRO)/devkitA64 + + AR := $(DEVKITA64)/bin/aarch64-none-elf-ar + AS := $(DEVKITA64)/bin/aarch64-none-elf-as + CC := $(DEVKITA64)/bin/aarch64-none-elf-gcc + CXX := $(DEVKITA64)/bin/aarch64-none-elf-g++ + + ifeq ($(LIBRARY),1) + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/lib/$(STRIPPED_NAME).a + else + OUTPUT_FILES := $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME).elf $(TARGET_OUTPUT_DIR)/switch/$(STRIPPED_NAME)/$(STRIPPED_NAME).nro + endif + + LD_FLAGS += -specs=$(DEVKITPRO)/libnx/switch.specs + COMMON_CC_FLAGS += -march=armv8-a -mtune=cortex-a57 -mtp=soft -fPIE -D__SWITCH__ + COMMON_CXX_FLAGS += -fno-rtti -fno-exceptions + + NRO_FLAGS := + + ifneq ("$(wildcard $(ICON))","") + NRO_FLAGS += --icon=$(ICON) + endif + + NACP_FLAGS := + + ifneq ($(TITLE_ID),) + NACP_FLAGS += --titleid=$(TITLE_ID) + endif +endif + +# FINAL COMMON SETUP # + +CLANG_CC := $(subst gcc,clang,$(CC)) +CLANG_CC_EXISTS := $(shell which $(CLANG_CC) > /dev/null 2> /dev/null; echo $$?) +ifeq ($(CLANG_CC_EXISTS),0) + CC := $(CLANG_CC) +endif + +CLANG_CXX := $(subst g++,clang++,$(CXX)) +CLANG_CXX_EXISTS := $(shell which $(CLANG_CXX) > /dev/null 2> /dev/null; echo $$?) +ifeq ($(CLANG_CXX_EXISTS),0) + CXX := $(CLANG_CXX) +endif + +CC_FLAGS := $(COMMON_CC_FLAGS) $(BUILD_FLAGS_CC) +CXX_FLAGS := $(COMMON_CC_FLAGS) $(COMMON_CXX_FLAGS) $(BUILD_FLAGS_CXX) + +ifeq ($(findstring -std,$(BUILD_FLAGS_CC)),) + CC_FLAGS += -std=gnu11 +endif + +ifeq ($(findstring -std,$(BUILD_FLAGS_CXX)),) + CXX_FLAGS += -std=gnu++11 +endif + +ifneq ($(EXTRA_OUTPUT_FILES),) + EXTRA_OUTPUT_COPY_CMD := cp -r $(EXTRA_OUTPUT_FILES) $(OUTPUT_DIR) +endif + +# MAIN RULES # + +.PHONY: all run install clean + +all: $(OUTPUT_ZIP_FILE) + +# TARGET RULES # + +ifeq ($(TARGET_OS),3ds) + +ifeq ($(LIBRARY),1) + +install: $(OUTPUT_ZIP_FILE) + @mkdir -p $(DEVKITPRO)/$(STRIPPED_NAME) + @cp -r $(TARGET_OUTPUT_DIR)/* $(DEVKITPRO)/$(STRIPPED_NAME) + @echo "Installed." + +else + +run: $(OUTPUT_ZIP_FILE) + @echo "Running..." + @citra $(RUN_FLAGS) $(TARGET_OUTPUT_DIR)/3ds/$(STRIPPED_NAME)/$(STRIPPED_NAME).3dsx + +runhw: $(OUTPUT_ZIP_FILE) + @echo "Running..." + @3dslink --address $(REMOTE_IP) $(TARGET_OUTPUT_DIR)/3ds/$(STRIPPED_NAME)/$(STRIPPED_NAME).3dsx + +install: $(OUTPUT_ZIP_FILE) + @echo "Installing..." + @$(SERVEFILES) $(REMOTE_IP) $(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME).cia + @echo "Installed." + +endif + +$(TARGET_BUILD_DIR)/%.shbin.o: $(TARGET_BUILD_DIR)/%.shbin.c + @echo $@ + @$(CC) -c $(CC_FLAGS) -MMD -MP -MF $(TARGET_BUILD_DIR)/$*.d $< -o $@ + +define shader-as + $(eval CURBIN := $(patsubst %.shbin.c,%.shbin,$@)) + @picasso -o $(CURBIN) $1 + @cd $(dir $(CURBIN)); \ + xxd -i $(notdir $(CURBIN)) "$(CURDIR)/$@" + echo "extern const u8" `(echo $(notdir $(CURBIN)) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(CURBIN) | tr . _)`.h + echo "extern const u32" `(echo $(notdir $(CURBIN)) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_len";" >> `(echo $(CURBIN) | tr . _)`.h +endef + +$(TARGET_BUILD_DIR)/%.shbin.c: %.v.pica %.g.pica + @echo $@ + @$(call shader-as,$^) + +$(TARGET_BUILD_DIR)/%.shbin.c: %.v.pica + @echo $@ + @$(call shader-as,$<) + +$(TARGET_BUILD_DIR)/%.shbin.c: %.shlist + @echo $@ + @$(call shader-as,$(foreach file,$(shell cat $<),$(dir $<)/$(file))) + +%.bnr: $(BANNER_IMAGE) $(BANNER_AUDIO) + @echo $@ + @bannertool makebanner $(BANNER_IMAGE_ARG) $(BANNER_IMAGE) $(BANNER_AUDIO_ARG) $(BANNER_AUDIO) -o $@ > /dev/null + +%.icn: $(ICON) + @echo $@ + @bannertool makesmdh -s "$(TITLE)" -l "$(TITLE) - $(DESCRIPTION)" -p "$(AUTHOR)" -i $(ICON) $(ICON_FLAGS) -o $@ > /dev/null + +%.smdh: $(ICON) + @echo $@ + @smdhtool --create "$(TITLE)" "$(DESCRIPTION)" "$(AUTHOR)" $(ICON) $@ + +$(TARGET_OUTPUT_DIR)/3ds/$(STRIPPED_NAME)/%.3dsx: $(TARGET_OUTPUT_DIR)/%.elf $(TARGET_BUILD_DIR)/meta.smdh + @echo $@ + @3dsxtool $< $@ --smdh=$(word 2,$^) $(_3DSXTOOL_FLAGS) + +%.3ds: %.elf $(TARGET_BUILD_DIR)/banner.bnr $(TARGET_BUILD_DIR)/icon.icn + @echo $@ + @makerom -f cci -o $@ -elf $< -DAPP_ENCRYPTED=true $(COMMON_MAKEROM_FLAGS) + +%.cia: %.elf $(TARGET_BUILD_DIR)/banner.bnr $(TARGET_BUILD_DIR)/icon.icn + @echo $@ + @makerom -f cia -o $@ -elf $< -DAPP_ENCRYPTED=false $(COMMON_MAKEROM_FLAGS) + +else ifeq ($(TARGET_OS),wiiu) + +ifeq ($(LIBRARY),1) + +install: $(OUTPUT_ZIP_FILE) + @mkdir -p $(DEVKITPRO)/$(STRIPPED_NAME) + @cp -r $(TARGET_OUTPUT_DIR)/* $(DEVKITPRO)/$(STRIPPED_NAME) + @echo "Installed." + +else + +runhw: $(OUTPUT_ZIP_FILE) + @echo "Running..." + @WIILOAD=tcp:$(REMOTE_IP) wiiload $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/$(STRIPPED_NAME).elf $(RUN_FLAGS) + +endif + +$(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml: + @echo $@ + @cp $(BUILDTOOLS_DIR)/wiiu/meta_template.xml $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml + @sed -i -- 's/$$(TITLE)/$(subst /,\/,$(TITLE))/g' $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml + @sed -i -- 's/$$(AUTHOR)/$(subst /,\/,$(AUTHOR))/g' $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml + @sed -i -- 's/$$(VERSION)/$(subst /,\/,$(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_MICRO))/g' $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml + @sed -i -- 's/$$(RELEASE_DATE)/$(subst /,\/,$(shell date +'%Y%m%d%H%M%S'))/g' $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml + @sed -i -- 's/$$(SHORT_DESCRIPTION)/$(subst /,\/,$(DESCRIPTION))/g' $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml + @sed -i -- 's/$$(LONG_DESCRIPTION)/$(subst /,\/,$(LONG_DESCRIPTION))/g' $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/meta.xml + +$(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/icon.png: + @echo $@ + @cp $(ICON) $(TARGET_OUTPUT_DIR)/wiiu/apps/$(STRIPPED_NAME)/icon.png + +else ifeq ($(TARGET_OS),switch) + +ifeq ($(LIBRARY),1) + +install: $(OUTPUT_ZIP_FILE) + @mkdir -p $(DEVKITPRO)/$(STRIPPED_NAME) + @cp -r $(TARGET_OUTPUT_DIR)/* $(DEVKITPRO)/$(STRIPPED_NAME) + @echo "Installed." + +else + +run: $(OUTPUT_ZIP_FILE) + @echo "Running..." + @yuzu-cmd $(RUN_FLAGS) $(TARGET_OUTPUT_DIR)/switch/$(STRIPPED_NAME)/$(STRIPPED_NAME).nro + +runhw: $(OUTPUT_ZIP_FILE) + @echo "Running..." + @nxlink --address $(REMOTE_IP) $(TARGET_OUTPUT_DIR)/switch/$(STRIPPED_NAME)/$(STRIPPED_NAME).nro + +endif + +%.nacp: + @echo $@ + @nacptool --create "$(TITLE)" "$(AUTHOR)" "$(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_MICRO)" $@ $(NACP_FLAGS) + +$(TARGET_OUTPUT_DIR)/switch/$(STRIPPED_NAME)/%.nro: $(TARGET_OUTPUT_DIR)/%.elf $(TARGET_BUILD_DIR)/meta.nacp + @echo $@ + @elf2nro $< $@ --nacp=$(word 2,$^) $(NRO_FLAGS) + +else ifeq ($(TARGET_OS),windows) + ifeq ($(HOST_OS),$(filter $(HOST_OS),linux mac)) + ifneq ($(LIBRARY),1) + +run: $(OUTPUT_FILES) $(OUTPUT_ZIP_FILE) + @echo "Running..." + @wine ./$< $(RUN_FLAGS) + + endif + else ifeq ($(HOST_OS),windows) + ifneq ($(LIBRARY),1) + +run: $(OUTPUT_FILES) $(OUTPUT_ZIP_FILE) + @echo "Running..." + @./$< $(RUN_FLAGS) + + endif + endif +else ifeq ($(TARGET_OS),$(filter $(TARGET_OS),mac linux)) + ifeq ($(HOST_OS),$(TARGET_OS)) + ifeq ($(LIBRARY),1) + +install: $(OUTPUT_ZIP_FILE) + @install -m 0755 $(OUTPUT_FILES) /usr/local/lib + @install -m 0644 $(foreach dir,$(INCLUDE_DIRS),$(wildcard $(dir)/*)) /usr/local/include + @echo "Installed." + + else + +run: $(OUTPUT_FILES) $(OUTPUT_ZIP_FILE) + @echo "Running..." + @./$< $(RUN_FLAGS) + +install: $(OUTPUT_ZIP_FILE) + @install -m 0755 $(OUTPUT_FILES) /usr/local/bin + @echo "Installed." + + endif + endif +endif + +# COMMON RULES # + +$(OUTPUT_ZIP_FILE): $(OUTPUT_FILES) $(EXTRA_OUTPUT_FILES) + +$(TARGET_OUTPUT_DIR)/$(STRIPPED_NAME): $(OBJECT_FILES) + @echo $@ + @$(CXX) $(CXX_FLAGS) $^ -o $@ $(LD_FLAGS) + +%.elf: $(OBJECT_FILES) + @echo $@ + @$(CXX) $(CXX_FLAGS) $^ -o $@ $(LD_FLAGS) + +%.a: $(OBJECT_FILES) + @echo $@ + @$(AR) -rc $@ $^ + +%.so: $(OBJECT_FILES) + @echo $@ + @$(CXX) $(CXX_FLAGS) -shared $^ -o $@ $(LD_FLAGS) + +%.exe: $(OBJECT_FILES) + @echo $@ + @$(CXX) $(CXX_FLAGS) $^ -o $@ $(LD_FLAGS) + +%.dll: $(OBJECT_FILES) + @echo $@ + @$(CXX) $(CXX_FLAGS) -shared $^ -o $@ $(LD_FLAGS) + +%.dylib: $(OBJECT_FILES) + @echo $@ + @$(CXX) $(CXX_FLAGS) -dynamiclib -undefined suppress -flat_namespace $^ -o $@ $(LD_FLAGS) + +$(TARGET_BUILD_DIR)/%.o: %.c + @echo $@ + @$(CC) -c $(CC_FLAGS) -MMD -MP -MF $(TARGET_BUILD_DIR)/$*.d $< -o $@ + +$(TARGET_BUILD_DIR)/%.o: %.cpp + @echo $@ + @$(CXX) -c $(CXX_FLAGS) -MMD -MP -MF $(TARGET_BUILD_DIR)/$*.d $< -o $@ + +$(TARGET_BUILD_DIR)/%.o: %.s + @echo $@ + @$(CC) -c $(CC_FLAGS) -MMD -MP -MF $(TARGET_BUILD_DIR)/$*.d -x assembler-with-cpp $< -o $@ + +$(TARGET_BUILD_DIR)/%.o: %.S + @echo $@ + @$(CC) -c $(CC_FLAGS) -MMD -MP -MF $(TARGET_BUILD_DIR)/$*.d -x assembler-with-cpp $< -o $@ + +$(TARGET_BUILD_DIR)/%.bin.o: $(TARGET_BUILD_DIR)/%.bin.c + @echo $@ + @$(CC) -c $(CC_FLAGS) -MMD -MP -MF $(TARGET_BUILD_DIR)/$*.d $< -o $@ + +$(TARGET_BUILD_DIR)/%.bin.c: %.bin + @echo $@ + @cd $(> `(echo $(TARGET_BUILD_DIR)/$< | tr . _)`.h + @echo "extern const u32" `(echo $(> `(echo $(TARGET_BUILD_DIR)/$< | tr . _)`.h + +$(foreach file,$(OBJECT_FILES),$(eval $(call createdirrule,$(file)))) +$(foreach file,$(OUTPUT_FILES),$(eval $(call createdirrule,$(file)))) + +# DEPENDS # + +DEPENDS := $(OBJECT_FILES:.o=.d) +-include $(DEPENDS) + +endif + +# CLEAN # + +clean: + @rm -rf $(BUILD_DIR) $(OUTPUT_DIR) + @echo "Cleaned." diff --git a/app/buildtools/wiiu/meta_template.xml b/app/buildtools/wiiu/meta_template.xml new file mode 100644 index 0000000..9e19b88 --- /dev/null +++ b/app/buildtools/wiiu/meta_template.xml @@ -0,0 +1,9 @@ + + + $(TITLE) + $(AUTHOR) + $(VERSION) + $(RELEASE_DATE) + $(SHORT_DESCRIPTION) + $(LONG_DESCRIPTION) + diff --git a/app/images/logo.bclim b/app/images/logo.bclim new file mode 100644 index 0000000000000000000000000000000000000000..f1be180dd87034422f5b524057538636e4905ef5 GIT binary patch literal 32808 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 E2iuI@^8f$< literal 0 HcmV?d00001 diff --git a/app/includes/3gx.h b/app/includes/3gx.h new file mode 100644 index 0000000..add525d --- /dev/null +++ b/app/includes/3gx.h @@ -0,0 +1,68 @@ +#include "3ds/types.h" + +#define _3GX_MAGIC (0x3230303024584733) /* "3GX$0002" */ + +typedef struct CTR_PACKED +{ + u32 authorLen; + const char* authorMsg; + u32 titleLen; + const char* titleMsg; + u32 summaryLen; + const char* summaryMsg; + u32 descriptionLen; + const char* descriptionMsg; + union { + u32 flags; + struct { + u32 embeddedExeLoadFunc : 1; + u32 embeddedSwapSaveLoadFunc : 1; + u32 memoryRegionSize : 2; + u32 compatibility : 2; + u32 eventsSelfManaged : 1; + u32 swapNotNeeded : 1; + u32 unused : 24; + }; + }; + u32 exeLoadChecksum; + u32 builtInLoadExeArgs[4]; + u32 builtInSwapSaveLoadArgs[4]; +} _3gx_Infos; + +typedef struct CTR_PACKED +{ + u32 count; + u32 * titles; +} _3gx_Targets; + +typedef struct CTR_PACKED +{ + u32 nbSymbols; + u32 symbolsOffset; + u32 nameTableOffset; +} _3gx_Symtable; + +typedef struct CTR_PACKED +{ + u32 codeOffset; + u32 rodataOffset; + u32 dataOffset; + u32 codeSize; + u32 rodataSize; + u32 dataSize; + u32 bssSize; + u32 exeLoadFuncOffset; // NOP terminated + u32 swapSaveFuncOffset; // NOP terminated + u32 swapLoadFuncOffset; // NOP terminated +} _3gx_Executable; + +typedef struct CTR_PACKED +{ + u64 magic; + u32 version; + u32 reserved; + _3gx_Infos infos; + _3gx_Executable executable; + _3gx_Targets targets; + _3gx_Symtable symtable; +} _3gx_Header; \ No newline at end of file diff --git a/app/includes/BCLIM.hpp b/app/includes/BCLIM.hpp new file mode 100644 index 0000000..46d8e95 --- /dev/null +++ b/app/includes/BCLIM.hpp @@ -0,0 +1,74 @@ +#pragma once +#include "3ds.h" +#include "tuple" +#include "CTRPluginFramework/Vector.hpp" +#include "CTRPluginFramework/Rect.hpp" +#include "CTRPluginFramework/Color.hpp" + +namespace CTRPluginFramework { + class BCLIM { + public: + enum class TextureFormat : u32 { + L8 = 0, + A8 = 1, + LA4 = 2, + LA8 = 3, + HILO8 = 4, + RGB565 = 5, + RGB8 = 6, + RGBA5551 = 7, + RGBA4 = 8, + RGBA8 = 9, + ETC1 = 10, + ETC1A4 = 11, + L4 = 12, + A4 = 13, + }; + struct Header { + u32 magic; + u16 endian; + u16 headerSize; + u32 version; + u32 fileSize; + u32 blockCount; + struct { + u32 magic; + u32 imagHeaderSize; + u16 width; + u16 height; + TextureFormat format; + } imag; + u32 dataLength; + }; + + BCLIM(void* bclimData, u32 bclimSize) : BCLIM(bclimData, (Header*)((u32)bclimData + bclimSize - 0x28)) {} + BCLIM(void* bclimData, Header* bclimHeader) : data(bclimData), header(bclimHeader) {} + + using ColorBlendCallback = Color(*)(const Color &, const Color &); + static std::pair OpaqueBlend() { + return std::make_pair(false, OpaqueBlendFunc); + } + + using RenderBackend = void(*)(void*, bool, Color*, int posX, int posY); + static std::pair RenderInterface() { + return std::make_pair(nullptr, RenderInterfaceBackend); + } + + void Render(const Rect& position, std::pair backend = RenderInterface(), const Rect& crop = Rect(0, 0, INT32_MAX, INT32_MAX), const Rect& limits = Rect(0, 0, 400, 240), std::pair colorBlend = OpaqueBlend()); + + void* data; + private: + Header* header; + static const u8 textureTileOrder[16]; + static const u8 etc1Modifiers[8][2]; + + template + inline T GetDataAt(int offset) { + return *(T*)(((u32)data) + offset); + } + + static void RenderInterfaceBackend(void* usrData, bool isRead, Color* c, int posX, int posY); + + static Color OpaqueBlendFunc(const Color& dst, const Color& src); + }; +} \ No newline at end of file diff --git a/app/includes/CTRPluginFramework/CTRPluginFramework.hpp b/app/includes/CTRPluginFramework/CTRPluginFramework.hpp new file mode 100644 index 0000000..c92e2ab --- /dev/null +++ b/app/includes/CTRPluginFramework/CTRPluginFramework.hpp @@ -0,0 +1,7 @@ +#pragma once + +#include "CTRPluginFramework/System/Mutex.hpp" +#include "CTRPluginFramework/System/Lock.hpp" +#include "CTRPluginFramework/Vector.hpp" +#include "CTRPluginFramework/Rect.hpp" +#include "CTRPluginFramework/Color.hpp" \ No newline at end of file diff --git a/app/includes/CTRPluginFramework/Clock.hpp b/app/includes/CTRPluginFramework/Clock.hpp new file mode 100644 index 0000000..ac62d8b --- /dev/null +++ b/app/includes/CTRPluginFramework/Clock.hpp @@ -0,0 +1,37 @@ +#pragma once +#include "3ds.h" +#include "CTRPluginFramework/Time.hpp" + +namespace CTRPluginFramework +{ + class Clock + { + public: + Clock(void) : _startTime(GetCurrentTime()) {} + constexpr Clock(const Time& time) : _startTime(time) {} + + __always_inline Time GetElapsedTime(void) const { + return (GetCurrentTime() - _startTime); + } + + __always_inline bool HasTimePassed(const Time& time) const { + return (GetElapsedTime() >= time); + } + + __always_inline Time Restart(void) { + const Time now = GetCurrentTime(); + + const Time ret = now - _startTime; + + _startTime = now; + return (ret); + } + private: + Time _startTime; + + static __always_inline Time GetCurrentTime(void) + { + return Ticks(svcGetSystemTick()); + } + }; +} diff --git a/app/includes/CTRPluginFramework/Color.hpp b/app/includes/CTRPluginFramework/Color.hpp new file mode 100644 index 0000000..5ffd836 --- /dev/null +++ b/app/includes/CTRPluginFramework/Color.hpp @@ -0,0 +1,67 @@ +#pragma once +#include "3ds/types.h" +#include +#include + +namespace CTRPluginFramework +{ + class Color + { + public: + + enum class BlendMode + { + Alpha, + Add, + Sub, + Mul, + None + }; + + constexpr Color(void) : a(255), b(0), g(0), r(0) {} + constexpr Color(u32 color) : raw(color) {} + constexpr Color(u8 red, u8 green, u8 blue, u8 alpha = 255) : a(alpha), b(blue), g(green), r(red) {} + + inline u32 ToU32(void) const { return raw; }; + Color &Fade(float fading); + Color Blend(const Color &color, BlendMode mode) const; + + inline bool operator == (const Color &right) const {return raw == right.raw;} + inline bool operator != (const Color &right) const {return raw != right.raw;} + bool operator < (const Color &right) const; + bool operator <= (const Color &right) const; + bool operator > (const Color &right) const; + bool operator >= (const Color &right) const; + Color operator + (const Color &right) const; + Color operator - (const Color &right) const; + Color operator * (const Color &right) const; + Color &operator += (const Color &right); + Color &operator -= (const Color &right); + Color &operator *= (const Color &right); + + operator std::string() const + { + char strColor[5] = { 0 }; + + strColor[0] = 0x1B; + strColor[1] = std::max((u8)1, r); + strColor[2] = std::max((u8)1, g); + strColor[3] = std::max((u8)1, b); + + return strColor; + } + + union + { + u32 raw; + struct // Match raw byte order + { + u8 a; + u8 b; + u8 g; + u8 r; + }; + }; + }; +} + diff --git a/app/includes/CTRPluginFramework/Rect.hpp b/app/includes/CTRPluginFramework/Rect.hpp new file mode 100644 index 0000000..f9aad0f --- /dev/null +++ b/app/includes/CTRPluginFramework/Rect.hpp @@ -0,0 +1,143 @@ +#pragma once +#include "CTRPluginFramework/Vector.hpp" +#include + +namespace CTRPluginFramework +{ + template + class Rect + { + public: + Rect(); + Rect(const Vector& leftTop, const Vector& size); + Rect(const Vector& leftTop, T width, T height); + Rect(T left, T top, const Vector& size); + Rect(T left, T top, T width, T height); + template + explicit Rect(const Rect& rect); + + bool Contains(T x, T y) const; + bool Contains(const Vector& point) const; + bool Intersects(const Rect& rect) const; + bool Intersects(const Rect& rect, Rect& intersect) const; + + Vector leftTop; + Vector size; + }; + + template + Rect::Rect() : leftTop(0, 0), size(0, 0) + { + + } + + template + Rect::Rect(const Vector& leftTopCorner, const Vector& size) + { + leftTop = leftTopCorner; + this->size = size; + } + + template + Rect::Rect(const Vector& leftTopCorner, T width, T height) + { + leftTop = leftTopCorner; + size.x = width; + size.y = height; + } + + template + Rect::Rect(T left, T top, const Vector& size) + { + leftTop.x = left; + leftTop.y = top; + this->size = size; + } + + template + Rect::Rect(T left, T top, T width, T height) + { + leftTop.x = left; + leftTop.y = top; + size.x = width; + size.y = height; + } + + template + template + Rect::Rect(const Rect& rect) + { + leftTop = reinterpret_cast(rect.leftTop); + size = reinterpret_cast(rect.size); + } + + template + bool Rect::Contains(T x, T y) const + { + T minX = std::min(leftTop.x, leftTop.x + size.x); + T maxX = std::max(leftTop.x, leftTop.x + size.x); + T minY = std::min(leftTop.y, leftTop.y + size.y); + T maxY = std::max(leftTop.y, leftTop.y + size.y); + + return (x >= minX && x < maxX + && y >= minY && y < maxY); + } + + template + bool Rect::Contains(const Vector& point) const + { + return (Contains(point.x, point.y)); + } + + template + bool Rect::Intersects(const Rect& rect) const + { + Rect intersect; + return (Intersects(rect, intersect)); + } + + template + bool Rect::Intersects(const Rect &rect, Rect &intersect) const + { + T thisMinX = std::min(leftTop.x, leftTop.x + size.x); + T thisMaxX = std::max(leftTop.x, leftTop.x + size.x); + T thisMinY = std::min(leftTop.y, leftTop.y + size.y); + T thisMaxY = std::max(leftTop.y, leftTop.y + size.y); + T rectMinX = std::min(rect.leftTop.x, rect.leftTop.x + rect.size.x); + T rectMaxX = std::max(rect.leftTop.x, rect.leftTop.x + rect.size.x); + T rectMinY = std::min(rect.leftTop.y, rect.leftTop.y + rect.size.y); + T rectMaxY = std::max(rect.leftTop.y, rect.leftTop.y + rect.size.y); + + T intersectLeftX = std::max(thisMinX, rectMinX); + T intersectLeftY = std::max(thisMinY, rectMinY); + T intersectRightX = std::min(thisMaxX, rectMaxX); + T intersectRightY = std::min(thisMaxY, rectMaxY); + + if (intersectLeftX < intersectRightX && intersectLeftY < intersectRightY) + { + intersect = Rect(intersectLeftX, intersectLeftY, intersectRightX - intersectLeftX, + intersectRightY - intersectLeftY); + return (true); + } + intersect = Rect(0, 0, 0, 0); + return (false); + } + + template + bool operator ==(Rect &left, Rect &right) + { + return (left.leftTop == right.leftTop + && left.size == right.size); + } + + template + bool operator !=(Rect &left, Rect &right) + { + return (left.leftTop != right.leftTop + && left.size != right.size); + } + + typedef Rect UIntRect; + typedef Rect IntRect; + typedef Rect FloatRect; +} diff --git a/app/includes/CTRPluginFramework/System/Lock.hpp b/app/includes/CTRPluginFramework/System/Lock.hpp new file mode 100644 index 0000000..6107e8e --- /dev/null +++ b/app/includes/CTRPluginFramework/System/Lock.hpp @@ -0,0 +1,54 @@ +#ifndef CTRPLUGINFRAMEWORK_SYSTEM_LOCK_HPP +#define CTRPLUGINFRAMEWORK_SYSTEM_LOCK_HPP + +#include "3ds.h" + +namespace CTRPluginFramework +{ + class Mutex; + class Lock + { + public: + inline explicit Lock(LightLock &llock) : + _type{LIGHTLOCK}, _llock{&llock} + { + LightLock_Lock(_llock); + } + + inline explicit Lock(RecursiveLock &rlock) : + _type{RECLOCK}, _rlock{&rlock} + { + RecursiveLock_Lock(_rlock); + } + + inline explicit Lock(Mutex &mutex) : + _type{MUTEX}, _mutex{&mutex} + { + mutex.Lock(); + } + + inline ~Lock(void) + { + if (_type == LIGHTLOCK) + LightLock_Unlock(_llock); + else if (_type == RECLOCK) + RecursiveLock_Unlock(_rlock); + else if (_type == MUTEX) + _mutex->Unlock(); + } + + private: + static const constexpr u32 LIGHTLOCK = 1; + static const constexpr u32 RECLOCK = 2; + static const constexpr u32 MUTEX = 3; + const u32 _type; + union + { + LightLock *_llock; + RecursiveLock *_rlock; + Mutex *_mutex; + }; + }; +} + +#endif diff --git a/app/includes/CTRPluginFramework/System/Mutex.hpp b/app/includes/CTRPluginFramework/System/Mutex.hpp new file mode 100644 index 0000000..ca1b9b8 --- /dev/null +++ b/app/includes/CTRPluginFramework/System/Mutex.hpp @@ -0,0 +1,41 @@ +#ifndef CTRPLUGINFRAMEWORK_SYSTEM_MUTEX_HPP +#define CTRPLUGINFRAMEWORK_SYSTEM_MUTEX_HPP + +#include "3ds.h" + +namespace CTRPluginFramework +{ + class Mutex + { + public: + inline Mutex(void) { + RecursiveLock_Init(&_lock); + } + inline ~Mutex(void) { + // I suppose that we can "force" unlock the mutex + if (_lock.counter > 0) + { + _lock.counter = 1; + RecursiveLock_Unlock(&_lock); + } + } + + inline void Lock(void) { + RecursiveLock_Lock(&_lock); + } + + // Return true on failure + inline bool TryLock(void) { + return RecursiveLock_TryLock(&_lock) != 0; + } + + inline void Unlock(void) { + RecursiveLock_Unlock(&_lock); + } + + private: + RecursiveLock _lock; + }; +} + +#endif diff --git a/app/includes/CTRPluginFramework/Time.hpp b/app/includes/CTRPluginFramework/Time.hpp new file mode 100644 index 0000000..5cd6b7c --- /dev/null +++ b/app/includes/CTRPluginFramework/Time.hpp @@ -0,0 +1,205 @@ +#pragma once + +#include "3ds/types.h" + +namespace CTRPluginFramework +{ + class Time + { + public : + + constexpr Time(void) : _ticks(0) {} + + + float AsSeconds(void) const; + + int AsMilliseconds(void) const; + + s64 AsMicroseconds(void) const; + + inline s64 AsTicks(void) const { return _ticks; } + + static const Time Zero; ///< Predefined "zero" time value + + static constexpr u32 TicksPerSecond = 268111856U; + + private : + + friend constexpr Time Seconds(float amount); + friend constexpr Time Milliseconds(int amount); + friend constexpr Time Microseconds(s64 amount); + friend constexpr Time Ticks(s64 amount); + + constexpr Time(s64 ticks) : _ticks(ticks) {} + + private : + + + s64 _ticks; + }; + + constexpr Time Seconds(float amount) + { + return (Time(static_cast(amount * Time::TicksPerSecond))); + } + + + constexpr Time Milliseconds(int amount) + { + return (Time(static_cast(amount * (Time::TicksPerSecond / 1000.f)))); + } + + + constexpr Time Microseconds(s64 amount) + { + return (Time(static_cast(amount * (Time::TicksPerSecond / 1000000.f)))); + } + + constexpr Time Ticks(s64 amount) + { + return (Time(amount)); + } + + inline bool operator ==(const Time& left, const Time& right) + { + return (left.AsTicks() == right.AsTicks()); + } + + + inline bool operator !=(const Time& left, const Time& right) + { + return (left.AsTicks() != right.AsTicks()); + } + + + inline bool operator <(const Time& left, const Time& right) + { + return (left.AsTicks() < right.AsTicks()); + } + + + inline bool operator >(const Time& left, const Time& right) + { + return (left.AsTicks() > right.AsTicks()); + } + + + inline bool operator <=(const Time& left, const Time& right) + { + return (left.AsTicks() <= right.AsTicks()); + } + + inline bool operator >=(const Time& left, const Time& right) + { + return (left.AsTicks() >= right.AsTicks()); + } + + inline Time operator -(const Time& right) + { + return (Ticks(-right.AsTicks())); + } + + + inline Time operator +(const Time& left, const Time& right) + { + return (Ticks(left.AsTicks() + right.AsTicks())); + } + + + inline Time& operator +=(Time& left, const Time& right) + { + return (left = left + right); + } + + + inline Time operator -(const Time& left, const Time& right) + { + return (Ticks(left.AsTicks() - right.AsTicks())); + } + + + inline Time& operator -=(Time& left, const Time& right) + { + return left = left - right; + } + + + inline Time operator *(const Time& left, float right) + { + return (Seconds(left.AsSeconds() * right)); + } + + + inline Time operator *(const Time& left, s64 right) + { + return (Microseconds(left.AsMicroseconds() * right)); + } + + + inline Time operator *(float left, const Time& right) + { + return (right * left); + } + + + inline Time operator *(s64 left, const Time& right) + { + return (right * left); + } + + + inline Time& operator *=(Time& left, float right) + { + return (left = left * right); + } + + + inline Time& operator *=(Time& left, s64 right) + { + return (left = left * right); + } + + + inline Time operator /(const Time& left, float right) + { + return Seconds(left.AsSeconds() / right); + } + + + inline Time operator /(const Time& left, s64 right) + { + return (Microseconds(left.AsMicroseconds() / right)); + } + + + inline Time& operator /=(Time& left, float right) + { + return (left = left / right); + } + + + inline Time& operator /=(Time& left, s64 right) + { + return (left = left / right); + } + + + inline float operator /(const Time& left, const Time& right) + { + return (left.AsSeconds() / right.AsSeconds()); + } + + + inline Time operator %(const Time& left, const Time& right) + { + return (Ticks(left.AsTicks() % right.AsTicks())); + } + + + inline Time& operator %=(Time& left, const Time& right) + { + return (left = left % right); + } + +} + diff --git a/app/includes/CTRPluginFramework/Vector.hpp b/app/includes/CTRPluginFramework/Vector.hpp new file mode 100644 index 0000000..c786d20 --- /dev/null +++ b/app/includes/CTRPluginFramework/Vector.hpp @@ -0,0 +1,124 @@ +#pragma once +#include "3ds/types.h" + +namespace CTRPluginFramework +{ + template + class Vector + { + public: + Vector(); + Vector(T x, T y); + template + explicit Vector(const Vector &vector); + + T x; + T y; + }; + + template + Vector::Vector() : x(0), y(0) + { + + } + + template + Vector::Vector(T x, T y) : x(x), y(y) + { + + } + + template + template + Vector::Vector(const Vector &vector) : x(static_cast(vector.x)), y(static_cast(vector.y)) + { + + } + + template + Vector operator - (const Vector &vector) + { + return (Vector(-vector.x, -vector.y)); + } + + template + Vector operator - (const Vector &left, const Vector &right) + { + return (Vector(left.x - right.x, left.y - right.y)); + } + + template + Vector &operator -= (const Vector &left, const Vector &right) + { + left.x -= right.x; + left.y -= right.y; + return (left); + } + + template + Vector operator + (const Vector &left, const Vector &right) + { + return (Vector(left.x + right.x, left.y + right.y)); + } + + template + Vector &operator += (const Vector &left, const Vector &right) + { + left.x += right.x; + left.y += right.y; + return (left); + } + + template + Vector operator * (const Vector &left, T right) + { + return (Vector(left.x * right, left.y * right)); + } + + template + Vector operator * (const T left, const Vector &right) + { + return (Vector(right.x * left, right.y * left)); + } + + template + Vector &operator *= (Vector &left, const T right) + { + left.x *= right; + left.y *= right; + return (left); + } + + template + Vector operator / (const Vector &left, const T right) + { + return (Vector(left.x / right, left.y / right)); + } + + template + Vector &operator /= (Vector &left, const T right) + { + left.x /= right; + left.y /= right; + return (left); + } + + template + bool operator <= (const Vector &left, const Vector &right) + { + return (left.x <= right.x + && left.y <= right.y); + } + + template + bool operator >= (const Vector &left, const Vector &right) + { + return (left.x >= right.x + && left.y >= right.y); + } + + typedef Vector UIntVector; + typedef Vector IntVector; + typedef Vector FloatVector; + typedef Vector shortVector; +} diff --git a/app/includes/Intellisense.hpp b/app/includes/Intellisense.hpp new file mode 100644 index 0000000..6b3cc9a --- /dev/null +++ b/app/includes/Intellisense.hpp @@ -0,0 +1,6 @@ +// Only used by Visual Studio Intellisense + +#define VERSION_MAJOR 0 +#define VERSION_MINOR 0 +#define VERSION_REVISION 1 +#define SERVER_PORT 5543 diff --git a/app/includes/Logger.hpp b/app/includes/Logger.hpp new file mode 100644 index 0000000..ca82c9c --- /dev/null +++ b/app/includes/Logger.hpp @@ -0,0 +1,47 @@ +#pragma once +#include "3ds.h" +#include "string" +#include "queue" +#include "CTRPluginFramework/System/Mutex.hpp" +#include "CTRPluginFramework/System/Lock.hpp" + +class Logger { +public: + Logger(); + void Start(); + void End(); + ~Logger(); + void Raw(bool isTopScr, const char* fmt, ...); + void Info(const char* fmt, ...); + void Debug(const char* fmt, ...); + void Warning(const char* fmt, ...); + void Error(const char* fmt, ...); + void Traffic(const char* fmt, ...); + + void Wait(); + + bool debug_enable = false; +private: + struct PendingLog { + enum class Type : u8 { + RAW, + DEBUG, + INFO, + WARNING, + ERROR, + TRAFFIC, + }; + Type type; + bool isTopScr = true; + std::string string; + }; + static void LoggerThread(void* arg); + void Handler(); + Thread thread; + LightEvent event; + + std::queue pendingLogs; + CTRPluginFramework::Mutex pendingLogsMutex; + + bool run = true; +}; \ No newline at end of file diff --git a/app/includes/Main.hpp b/app/includes/Main.hpp new file mode 100644 index 0000000..1be7d50 --- /dev/null +++ b/app/includes/Main.hpp @@ -0,0 +1,5 @@ +#pragma once +#include "3ds.h" +#include "Logger.hpp" + +extern Logger logger; \ No newline at end of file diff --git a/app/includes/csvc.h b/app/includes/csvc.h new file mode 100644 index 0000000..543a2a6 --- /dev/null +++ b/app/includes/csvc.h @@ -0,0 +1,154 @@ +/* This paricular file is licensed under the following terms: */ + +/* +* This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable +* for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it +* and redistribute it freely, subject to the following restrictions: +* +* The origin of this software must not be misrepresented; you must not claim that you wrote the original software. +* If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +* +* Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +* This notice may not be removed or altered from any source distribution. +*/ + +#pragma once + +#include <3ds/types.h> + +/// Operations for svcControlService +typedef enum ServiceOp +{ + SERVICEOP_STEAL_CLIENT_SESSION = 0, ///< Steal a client session given a service or global port name + SERVICEOP_GET_NAME, ///< Get the name of a service or global port given a client or session handle +} ServiceOp; + +/** + * @brief Executes a function in supervisor mode, using the supervisor-mode stack. + * @param func Function to execute. + * @param ... Function parameters, up to 3 registers. +*/ +Result svcCustomBackdoor(void *func, ...); + +///@name I/O +///@{ +/** + * @brief Gives the physical address corresponding to a virtual address. + * @param VA Virtual address. + * @param writeCheck whether to check if the VA is writable in supervisor mode + * @return The corresponding physical address, or NULL. +*/ +u32 svcConvertVAToPA(const void *VA, bool writeCheck); + +/** + * @brief Flushes a range of the data cache (L2C included). + * @param addr Start address. + * @param len Length of the range. +*/ +void svcFlushDataCacheRange(void *addr, u32 len); + +/** + * @brief Flushes the data cache entirely (L2C included). +*/ +void svcFlushEntireDataCache(void); + +/** + * @brief Invalidates a range of the instruction cache. + * @param addr Start address. + * @param len Length of the range. +*/ +void svcInvalidateInstructionCacheRange(void *addr, u32 len); + +/** + * @brief Invalidates the data cache entirely. +*/ +void svcInvalidateEntireInstructionCache(void); +///@} + +///@name Memory management +///@{ +/** + * @brief Maps a block of process memory. + * @param dstProcessHandle Handle of the process to map the memory in (destination) + * @param destAddress Address of the mapped block in the current process. + * @param srcProcessHandle Handle of the process to map the memory from (source) + * @param srcAddress Address of the mapped block in the source process. + * @param size Size of the block of the memory to map (truncated to a multiple of 0x1000 bytes). +*/ +Result svcMapProcessMemoryEx(Handle dstProcessHandle, u32 destAddress, Handle srcProcessHandle, u32 vaSrc, u32 size); + +/** + * @brief Unmaps a block of process memory. + * @param process Handle of the process to unmap the memory from + * @param destAddress Address of the block of memory to unmap + * @param size Size of the block of memory to unmap (truncated to a multiple of 0x1000 bytes). + * This function should only be used to unmap memory mapped with svcMapProcessMemoryEx + */ +Result svcUnmapProcessMemoryEx(Handle process, u32 destAddress, u32 size); + +/** + * @brief Controls memory mapping, with the choice to use region attributes or not. + * @param[out] addr_out The virtual address resulting from the operation. Usually the same as addr0. + * @param addr0 The virtual address to be used for the operation. + * @param addr1 The virtual address to be (un)mirrored by @p addr0 when using @ref MEMOP_MAP or @ref MEMOP_UNMAP. + * It has to be pointing to a RW memory. + * Use NULL if the operation is @ref MEMOP_FREE or @ref MEMOP_ALLOC. + * @param size The requested size for @ref MEMOP_ALLOC and @ref MEMOP_ALLOC_LINEAR. + * @param op Operation flags. See @ref MemOp. + * @param perm A combination of @ref MEMPERM_READ and @ref MEMPERM_WRITE. Using MEMPERM_EXECUTE will return an error. + * Value 0 is used when unmapping memory. + * @param isLoader Whether to use the region attributes + * If a memory is mapped for two or more addresses, you have to use MEMOP_UNMAP before being able to MEMOP_FREE it. + * MEMOP_MAP will fail if @p addr1 was already mapped to another address. + * + * @sa svcControlMemory + */ +Result svcControlMemoryEx(u32* addr_out, u32 addr0, u32 addr1, u32 size, MemOp op, MemPerm perm, bool isLoader); +///@} + +///@name System +///@{ +/** + * @brief Performs actions related to services or global handles. + * @param op The operation to perform, see @ref ServiceOp. + * + * Examples: + * svcControlService(SERVICEOP_GET_NAME, (char [12])outName, (Handle)clientOrSessionHandle); + * svcControlService(SERVICEOP_STEAL_CLIENT_SESSION, (Handle *)&outHandle, (const char *)name); + */ +Result svcControlService(ServiceOp op, ...); + +/** + * @brief Copy a handle from a process to another one. + * @param[out] out The output handle. + * @param outProcess Handle of the process of the output handle. + * @param in The input handle. Pseudo-handles are not accepted. + * @param inProcess Handle of the process of the input handle. +*/ +Result svcCopyHandle(Handle *out, Handle outProcess, Handle in, Handle inProcess); + +/** + * @brief Get the address and class name of the underlying kernel object corresponding to a handle. + * @param[out] outKAddr The output kernel address. + * @param[out] outName Output class name. The buffer should be large enough to contain it. + * @param in The input handle. +*/ +Result svcTranslateHandle(u32 *outKAddr, char *outClassName, Handle in); + +/// Operations for svcControlProcess +typedef enum ProcessOp +{ + PROCESSOP_GET_ALL_HANDLES, ///< List all handles of the process, varg3 can be either 0 to fetch all handles, or token of the type to fetch + ///< svcControlProcess(handle, PROCESSOP_GET_ALL_HANDLES, (u32)&outBuf, 0) + PROCESSOP_SET_MMU_TO_RWX, ///< Set the whole memory of the process with rwx access + ///< svcControlProcess(handle, PROCESSOP_SET_MMU_TO_RWX, 0, 0) + PROCESSOP_GET_ON_MEMORY_CHANGE_EVENT, + PROCESSOP_GET_ON_EXIT_EVENT, + PROCESSOP_GET_PA_FROM_VA, ///< Get the physical address of the va within the process + ///< svcControlProcess(handle, PROCESSOP_GET_PA_FROM_VA, (u32)&outPa, va) +} ProcessOp; + +Result svcControlProcess(Handle process, ProcessOp op, u32 varg2, u32 varg3); +///@} diff --git a/app/includes/logo.h b/app/includes/logo.h new file mode 100644 index 0000000..9ffb462 --- /dev/null +++ b/app/includes/logo.h @@ -0,0 +1,9 @@ +/* Generated by bin2c, do not edit manually */ +#ifndef ____includes_logo_h_included +#define ____includes_logo_h_included + +/* Contents of file .\data\logo.bin */ +extern const long int __data_logo_bin_size; +extern const unsigned char __data_logo_bin[32808]; + +#endif /* ____includes_logo_h_included */ diff --git a/app/includes/plgldr.h b/app/includes/plgldr.h new file mode 100644 index 0000000..5de239c --- /dev/null +++ b/app/includes/plgldr.h @@ -0,0 +1,36 @@ +#pragma once +#ifdef __cplusplus +extern "C" { +#endif + +#include <3ds/types.h> + +typedef struct +{ + bool noFlash; + u8 pluginMemoryStrategy; + u8 persistent; + u32 lowTitleId; + char path[256]; + u32 config[32]; +} PluginLoadParameters; + +typedef enum +{ + PLG_STRATEGY_NONE = 2, + PLG_STRATEGY_SWAP = 0, + PLG_STRATEGY_MODE3 = 1 +} PluginMemoryStrategy; + +Result plgLdrInit(void); +void plgLdrExit(void); +Result PLGLDR__IsPluginLoaderEnabled(bool *isEnabled); +Result PLGLDR__SetPluginLoaderState(bool enabled); +Result PLGLDR__SetPluginLoadParameters(PluginLoadParameters *parameters); +Result PLGLDR__GetVersion(u32* version); +Result PLGLDR__SetExeDecSettings(void* decFunc, void* args); +Result PLGLDR__ClearPluginLoadParameters(); + +#ifdef __cplusplus +} +#endif diff --git a/app/resources/audio.cwav b/app/resources/audio.cwav new file mode 100644 index 0000000000000000000000000000000000000000..fd185d208000b630331e07146296d7ce2bdbf5c6 GIT binary patch literal 57560 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 literal 0 HcmV?d00001 diff --git a/app/resources/icon.pdn b/app/resources/icon.pdn new file mode 100644 index 0000000000000000000000000000000000000000..1ad45fc091adcf42fe7e1ccb1c8146310c65c6a4 GIT binary patch literal 10389 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 literal 0 HcmV?d00001 diff --git a/app/resources/icon.png b/app/resources/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..b47e554d2b746a419dce8b5ebbcafa96cd9c50e1 GIT binary patch literal 3490 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 literal 0 HcmV?d00001 diff --git a/app/resources/logo.bcma.lz b/app/resources/logo.bcma.lz new file mode 100644 index 0000000000000000000000000000000000000000..096228b05a409c7db4a9bb74f03a6e68bcc1a5e4 GIT binary patch literal 8192 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 gFWx=AJ@1o$)^z@@e-Zc>fqxPB7lD5f_ 255) Color = 255; + if (Color < 0) Color = 0; + return Color; + } + + const u8 BCLIM::textureTileOrder[] = + { + 0, 1, 4, 5, + 2, 3, 6, 7, + + 8, 9, 12, 13, + 10, 11, 14, 15 + }; + + const u8 BCLIM::etc1Modifiers[][2] = + { + { 2, 8 }, + { 5, 17 }, + { 9, 29 }, + { 13, 42 }, + { 18, 60 }, + { 24, 80 }, + { 33, 106 }, + { 47, 183 } + }; + + Color BCLIM::OpaqueBlendFunc(const Color& dst, const Color& src) { + return dst; + } + + static Color ReadPixel(void* fb, int posX, int posY) { + constexpr u32 _bytesPerPixel = 2; + constexpr u32 _rowSize = 240; + u32 offset = (_rowSize - 1 - posY + posX * _rowSize) * _bytesPerPixel; + union + { + u16 u; + u8 b[2]; + } half; + half.u = *reinterpret_cast((u32)fb + offset); + Color c; + c.r = (half.u >> 8) & 0xF8; + c.g = (half.u >> 3) & 0xFC; + c.b = (half.u << 3) & 0xF8; + c.a = 255; + return c; + } + static void WritePixel(void* fb, int posX, int posY, const Color& c) { + constexpr u32 _bytesPerPixel = 2; + constexpr u32 _rowSize = 240; + u32 offset = (_rowSize - 1 - posY + posX * _rowSize) * _bytesPerPixel; + union + { + u16 u; + u8 b[2]; + } half; + half.u = (c.r & 0xF8) << 8; + half.u |= (c.g & 0xFC) << 3; + half.u |= (c.b & 0xF8) >> 3; + *reinterpret_cast((u32)fb + offset) = half.u; + } + + void BCLIM::RenderInterfaceBackend(void* usrData, bool isRead, Color* c, int posX, int posY) { + if (isRead) { + *c = ReadPixel(gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL), posX, posY); + } else { + WritePixel(gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL), posX, posY, *c); + } + } + + static bool FastContains(const Rect& rect, Vector point) { + return point.x >= rect.leftTop.x && point.x < (rect.leftTop.x + rect.size.x) && + point.y >= rect.leftTop.y && point.y < (rect.leftTop.y + rect.size.y); + } + + void BCLIM::Render(const Rect& position, std::pair backend, const Rect& crop, const Rect& limits, std::pair colorBlender) { + auto mappingScale = [](const Rect& position, int x, int y, int w, int h) { + int posX = position.leftTop.x; + int posY = position.leftTop.y; + float progX = x/(float)w; + float progY = y/(float)h; + + return Vector(posX + position.size.x * progX, posY + position.size.y * progY); + }; + auto mappingDirect = [](const Rect& position, int x, int y, int w, int h) { + return Vector(position.leftTop.x + x, position.leftTop.y + y); + }; + Vector(*mapping)(const Rect& position, int x, int y, int w, int h); + Color current; + + if (position.size.x == header->imag.width && position.size.y == header->imag.height) + mapping = mappingDirect; + else + mapping = mappingScale; + + switch (header->imag.format) { + case TextureFormat::L8: + case TextureFormat::A8: + case TextureFormat::LA4: + case TextureFormat::LA8: + case TextureFormat::HILO8: + case TextureFormat::RGB8: + case TextureFormat::RGBA5551: + case TextureFormat::RGBA8: + case TextureFormat::ETC1: + case TextureFormat::L4: + case TextureFormat::A4: + case TextureFormat::RGBA4: + case TextureFormat::ETC1A4: + break; + case TextureFormat::RGB565: + { + int offs = 0; + Vector prevPos(-1, -1); + for (int y = 0; y < header->imag.height; y+=8) { + for (int x = 0; x < header->imag.width; x+=8) { + for (int i = 0; i < 64; i++) { + int x2 = i % 8; + if (x + x2 >= crop.size.x || x + x2 >= header->imag.width) continue; + int y2 = i / 8; + if (y + y2 >= crop.size.y || y + y2 >= header->imag.height) continue; + auto drawPos = mapping(position, x + x2, y + y2, header->imag.width, header->imag.height); + if (!FastContains(limits, drawPos)) continue; + if (drawPos.x != prevPos.x || drawPos.y != prevPos.y) { + prevPos = drawPos; + int pos = textureTileOrder[x2 % 4 + y2 % 4 * 4] + 16 * (x2 / 4) + 32 * (y2 / 4); + u16 pixel = GetDataAt(offs + pos * 2); + u8 b = (u8)((pixel & 0x1F) << 3); + u8 g = (u8)((pixel & 0x7E0) >> 3); + u8 r = (u8)((pixel & 0xF800) >> 8); + if (colorBlender.first) + backend.second(backend.first, true, ¤t, drawPos.x, drawPos.y); + Color finalcolor = colorBlender.second(Color(r, g, b), current); + backend.second(backend.first, false, &finalcolor, drawPos.x, drawPos.y); + } + } + offs += 64 * 2; + } + } + } + break; + } + } +} \ No newline at end of file diff --git a/app/sources/CTRPluginFramework/Color.cpp b/app/sources/CTRPluginFramework/Color.cpp new file mode 100644 index 0000000..7ba73de --- /dev/null +++ b/app/sources/CTRPluginFramework/Color.cpp @@ -0,0 +1,158 @@ +#include "CTRPluginFramework/Color.hpp" +#include + +namespace CTRPluginFramework +{ + Color& Color::Fade(float fading) + { + if (fading > 1.0f || fading < -1.0f) + return *this; + + if (fading > 0.0f) + { + float tint = 1.f - fading; + r = std::min((int)(255 - (255 - r) * tint), 255); + g = std::min((int)(255 - (255 - g) * tint), 255); + b = std::min((int)(255 - (255 - b) * tint), 255); + } + else + { + float shade = 1.f + fading; + + r *= shade; + g *= shade; + b *= shade; + } + return *this; + } + + Color Color::Blend(const Color &color, BlendMode mode) const + { + // This is background, color is foreground + Color ret; + unsigned int _r; + unsigned int _g; + unsigned int _b; + unsigned int _a; + float forealpha = (float)color.a / 255.f; + float minusForeAlpha = 1.f - forealpha; + + switch (mode) + { + case BlendMode::Alpha: + _r = (forealpha * (float)color.r) + ((float)r * minusForeAlpha); + _g = (forealpha * (float)color.g) + ((float)g * minusForeAlpha); + _b = (forealpha * (float)color.b) + ((float)b * minusForeAlpha); + _a = color.a * a; + ret.r = std::min(_r, 255u); + ret.g = std::min(_g, 255u); + ret.b = std::min(_b, 255u); + ret.a = std::min(_a, 255u); + break; + case BlendMode::Add: + _r = a * r / 255 + 255 * color.r / 255; + _g = a * g / 255 + 255 * color.g / 255; + _b = a * b / 255 + 255 * color.b / 255; + _a = a + color.a; + ret.r = std::min(_r, 255u); + ret.g = std::min(_g, 255u); + ret.b = std::min(_b, 255u); + ret.a = std::min(_a, 255u); + break; + case BlendMode::Sub: + _r = a * r / 255 - 255 * color.r / 255; + _g = a * g / 255 - 255 * color.g / 255; + _b = a * b / 255 - 255 * color.b / 255; + _a = a - color.a; + ret.r = std::max(_r, 0u); + ret.g = std::max(_g, 0u); + ret.b = std::max(_b, 0u); + ret.a = std::max(_a, 0u); + break; + case BlendMode::Mul: + ret = *this * color; + break; + default: + ret = color; + break; + } + return (ret); + } + + bool Color::operator < (const Color &right) const + { + return (( r < right.r) + && (b < right.b) + && (g < right.g)); + } + + bool Color::operator <= (const Color &right) const + { + return (( r <= right.r) + && (b <= right.b) + && (g <= right.g)); + } + + bool Color::operator > (const Color &right) const + { + return (( r > right.r) + && (b > right.b) + && (g > right.g)); + } + + bool Color::operator >= (const Color &right) const + { + return (( r >= right.r) + && (b >= right.b) + && (g >= right.g)); + } + + Color Color::operator+(const Color& right) const + { + u8 _r(std::min(r + right.r, 255)); + u8 _g(std::min(g + right.g, 255)); + u8 _b(std::min(b + right.b, 255)); + u8 _a(std::min(a + right.a, 255)); + + return (Color(_r, _g, _b, _a)); + + } + + Color Color::operator-(const Color& right) const + { + u8 _r(std::max(r - right.r, 0)); + u8 _g(std::max(g - right.g, 0)); + u8 _b(std::max(b - right.b, 0)); + u8 _a(std::max(a - right.a, 0)); + + return (Color(_r, _g, _b, _a)); + } + + Color Color::operator*(const Color& right) const + { + u8 _r(r * right.r / 255); + u8 _g(g * right.g / 255); + u8 _b(b * right.b / 255); + u8 _a(a * right.a / 255); + + return (Color(_r, _g, _b, _a)); + } + + Color &Color::operator+=(const Color& right) + { + *this = *this + right; + return (*this); + } + + Color &Color::operator-=(const Color& right) + { + *this = *this - right; + return (*this); + } + + Color &Color::operator*=(const Color& right) + { + *this = *this * right; + return (*this); + } + } diff --git a/app/sources/CTRPluginFramework/Time.cpp b/app/sources/CTRPluginFramework/Time.cpp new file mode 100644 index 0000000..c928203 --- /dev/null +++ b/app/sources/CTRPluginFramework/Time.cpp @@ -0,0 +1,26 @@ +#include "3ds/types.h" + +#include "CTRPluginFramework/Time.hpp" + +namespace CTRPluginFramework +{ + const Time Time::Zero; + + float Time::AsSeconds(void) const + { + return (_ticks / (float)TicksPerSecond); + } + + + int Time::AsMilliseconds(void) const + { + return static_cast(_ticks / (TicksPerSecond / 1000.f)); + } + + + s64 Time::AsMicroseconds(void) const + { + return static_cast(_ticks / (TicksPerSecond / 1000000.f)); + } + +} diff --git a/app/sources/Logger.cpp b/app/sources/Logger.cpp new file mode 100644 index 0000000..5daaf07 --- /dev/null +++ b/app/sources/Logger.cpp @@ -0,0 +1,178 @@ +#include "Logger.hpp" +#include +#include +#include +#include "3ds.h" + +Logger::Logger() {} + +void Logger::Start() { + LightEvent_Init(&event, ResetType::RESET_ONESHOT); + + s32 prio = 0; + svcGetThreadPriority(&prio, CUR_THREAD_HANDLE); + + thread = threadCreate(LoggerThread, this, 0x300, prio + 1, -2, false); +} + +void Logger::End() { + run = false; + LightEvent_Signal(&event); + threadJoin(thread, U64_MAX); +} + +Logger::~Logger() { + if (run) End(); + threadFree(thread); +} + +extern PrintConsole topScreenConsole, bottomScreenConsole; + +void Logger::Raw(bool isTopScr, const char* fmt, ...) { + va_list valist; + char buffer[256]; + va_start(valist, fmt); + int ret = vsnprintf(buffer, 255, fmt, valist); + va_end(valist); + if (ret >= 0) buffer[ret] = '\0'; + { + CTRPluginFramework::Lock l(pendingLogsMutex); + pendingLogs.push(PendingLog{.type = PendingLog::Type::RAW, .isTopScr = isTopScr, .string{buffer}}); + } + LightEvent_Signal(&event); +} + +void Logger::Info(const char* fmt, ...) { + va_list valist; + char buffer[256]; + va_start(valist, fmt); + int ret = vsnprintf(buffer, 255, fmt, valist); + va_end(valist); + if (ret >= 0) buffer[ret] = '\0'; + { + CTRPluginFramework::Lock l(pendingLogsMutex); + pendingLogs.push(PendingLog{.type = PendingLog::Type::INFO, .isTopScr = true, .string{buffer}}); + } + LightEvent_Signal(&event); +} + +void Logger::Debug(const char* fmt, ...) { + if (!debug_enable) return; + va_list valist; + char buffer[256]; + va_start(valist, fmt); + int ret = vsnprintf(buffer, 255, fmt, valist); + va_end(valist); + if (ret >= 0) buffer[ret] = '\0'; + { + CTRPluginFramework::Lock l(pendingLogsMutex); + pendingLogs.push(PendingLog{.type = PendingLog::Type::DEBUG, .isTopScr = true, .string{buffer}}); + } + LightEvent_Signal(&event); +} + +void Logger::Warning(const char* fmt, ...) { + va_list valist; + char buffer[256]; + va_start(valist, fmt); + int ret = vsnprintf(buffer, 255, fmt, valist); + va_end(valist); + if (ret >= 0) buffer[ret] = '\0'; + { + CTRPluginFramework::Lock l(pendingLogsMutex); + pendingLogs.push(PendingLog{.type = PendingLog::Type::WARNING, .isTopScr = true, .string{buffer}}); + } + LightEvent_Signal(&event); +} + +void Logger::Error(const char* fmt, ...) { + va_list valist; + char buffer[256]; + va_start(valist, fmt); + int ret = vsnprintf(buffer, 255, fmt, valist); + va_end(valist); + if (ret >= 0) buffer[ret] = '\0'; + { + CTRPluginFramework::Lock l(pendingLogsMutex); + pendingLogs.push(PendingLog{.type = PendingLog::Type::ERROR, .isTopScr = true, .string{buffer}}); + } + LightEvent_Signal(&event); +} + +void Logger::Traffic(const char* fmt, ...) { + va_list valist; + char buffer[256]; + va_start(valist, fmt); + int ret = vsnprintf(buffer, 255, fmt, valist); + va_end(valist); + if (ret >= 0) buffer[ret] = '\0'; + { + CTRPluginFramework::Lock l(pendingLogsMutex); + pendingLogs.push(PendingLog{.type = PendingLog::Type::TRAFFIC, .isTopScr = false, .string{buffer}}); + } + LightEvent_Signal(&event); +} + +void Logger::Handler() { + bool currentIsTop = true; + int back; + while (true) { + LightEvent_Wait(&event); + if (!run) { + break; + } + while (run) { + PendingLog log; + { + CTRPluginFramework::Lock l(pendingLogsMutex); + if (!pendingLogs.size()) + break; + log = pendingLogs.front(); + pendingLogs.pop(); + } + if (log.isTopScr && !currentIsTop) { + currentIsTop = true; + consoleSelect(&topScreenConsole); + } + if (!log.isTopScr && currentIsTop) { + currentIsTop = false; + consoleSelect(&bottomScreenConsole); + } + switch (log.type) + { + case PendingLog::Type::RAW: + printf("%s\n", log.string.c_str()); + break; + case PendingLog::Type::DEBUG: + printf("[D] %s\n", log.string.c_str()); + break; + case PendingLog::Type::INFO: + printf("[I] %s\n", log.string.c_str()); + break; + case PendingLog::Type::WARNING: + topScreenConsole.fg = 19; + printf("[W] %s\n", log.string.c_str()); + topScreenConsole.fg = 0; + break; + case PendingLog::Type::ERROR: + topScreenConsole.fg = 17; + printf("[E] %s\n", log.string.c_str()); + topScreenConsole.fg = 0; + break; + case PendingLog::Type::TRAFFIC: + back = bottomScreenConsole.cursorY; + bottomScreenConsole.cursorY = 25; + printf(log.string.c_str()); + bottomScreenConsole.cursorY = back; + break; + default: + break; + } + } + } +} + +void Logger::LoggerThread(void* arg) { + Logger* l = (Logger*)arg; + l->Handler(); +} \ No newline at end of file diff --git a/app/sources/csvc.s b/app/sources/csvc.s new file mode 100644 index 0000000..da69875 --- /dev/null +++ b/app/sources/csvc.s @@ -0,0 +1,122 @@ +@ This paricular file is licensed under the following terms: + +@ This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable +@ for any damages arising from the use of this software. +@ +@ Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it +@ and redistribute it freely, subject to the following restrictions: +@ +@ The origin of this software must not be misrepresented; you must not claim that you wrote the original software. +@ If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +@ +@ Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +@ This notice may not be removed or altered from any source distribution. + +.arm +.balign 4 + +.macro SVC_BEGIN name + .section .text.\name, "ax", %progbits + .global \name + .type \name, %function + .align 2 + .cfi_startproc +\name: +.endm + +.macro SVC_END + .cfi_endproc +.endm + +SVC_BEGIN svcCustomBackdoor + svc 0x80 + bx lr +SVC_END + +SVC_BEGIN svcConvertVAToPA + svc 0x90 + bx lr +SVC_END + +SVC_BEGIN svcFlushDataCacheRange + svc 0x91 + bx lr +SVC_END + +SVC_BEGIN svcFlushEntireDataCache + svc 0x92 + bx lr +SVC_END + +SVC_BEGIN svcInvalidateInstructionCacheRange + svc 0x93 + bx lr +SVC_END + +SVC_BEGIN svcInvalidateEntireInstructionCache + svc 0x94 + bx lr +SVC_END + +SVC_BEGIN svcMapProcessMemoryEx + str r4, [sp, #-4]! + ldr r4, [sp, #4] + svc 0xA0 + ldr r4, [sp], #4 + bx lr +SVC_END + +SVC_BEGIN svcUnmapProcessMemoryEx + svc 0xA1 + bx lr +SVC_END + +SVC_BEGIN svcControlMemoryEx + push {r0, r4, r5} + ldr r0, [sp, #0xC] + ldr r4, [sp, #0xC+0x4] + ldr r5, [sp, #0xC+0x8] + svc 0xA2 + pop {r2, r4, r5} + str r1, [r2] + bx lr +SVC_END + +SVC_BEGIN svcControlMemoryUnsafe + str r4, [sp, #-4]! + ldr r4, [sp, #4] + svc 0xA3 + ldr r4, [sp], #4 + bx lr +SVC_END + +SVC_BEGIN svcFreeMemory + svc 0xA3 + bx lr +SVC_END + +SVC_BEGIN svcControlService + svc 0xB0 + bx lr +SVC_END + +SVC_BEGIN svcCopyHandle + str r0, [sp, #-4]! + svc 0xB1 + ldr r2, [sp], #4 + str r1, [r2] + bx lr +SVC_END + +SVC_BEGIN svcTranslateHandle + str r0, [sp, #-4]! + svc 0xB2 + ldr r2, [sp], #4 + str r1, [r2] + bx lr +SVC_END + +SVC_BEGIN svcControlProcess + svc 0xB3 + bx lr +SVC_END diff --git a/app/sources/logo.c b/app/sources/logo.c new file mode 100644 index 0000000..e6082d9 --- /dev/null +++ b/app/sources/logo.c @@ -0,0 +1,2057 @@ +/* Generated by bin2c, do not edit manually */ + +/* Contents of file .\data\logo.bin */ +const long int __data_logo_bin_size = 32808; +const unsigned char __data_logo_bin[32808] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, 0x92, 0x94, + 0x7D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0x1C, 0xE7, 0x5D, 0xEF, 0x3C, 0xE7, 0xFB, 0xDE, 0xFB, 0xDE, + 0x96, 0xB5, 0x0C, 0x63, 0x20, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x8E, 0x73, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0xFB, 0xDE, 0x5D, 0xEF, 0x7D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, + 0x34, 0xA5, 0x79, 0xCE, 0x00, 0x00, 0x86, 0x31, 0x9A, 0xD6, 0xBA, 0xD6, 0x10, 0x84, 0x38, 0xC6, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, + 0xDB, 0xDE, 0xFB, 0xDE, 0x59, 0xCE, 0x9A, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0x1C, 0xE7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, + 0x7D, 0xEF, 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0xF7, 0xBD, 0x61, 0x08, 0x0C, 0x63, 0x00, 0x00, + 0x1C, 0xE7, 0xBA, 0xD6, 0xFB, 0xDE, 0xD7, 0xBD, 0x04, 0x21, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x04, 0x21, 0x00, 0x00, 0x78, 0xCE, 0xAA, 0x52, 0x20, 0x00, 0xDE, 0xFF, 0x3B, 0xE7, + 0x0F, 0x84, 0xFE, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0x34, 0xA5, 0xDB, 0xDE, 0xF3, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDB, 0xDE, 0x14, 0xA5, 0xDB, 0xDE, 0x96, 0xB5, 0x20, 0x00, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, + 0x58, 0xCE, 0xFF, 0xFF, 0x99, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x38, 0xC6, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x74, 0xAD, 0x48, 0x4A, 0x00, 0x00, 0x45, 0x29, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0x85, 0x31, 0xFF, 0xFF, 0x5B, 0xEF, + 0x51, 0x8C, 0x18, 0xC6, 0x00, 0x00, 0x28, 0x42, 0x59, 0xCE, 0x9A, 0xD6, 0x75, 0xAD, 0x38, 0xC6, + 0x00, 0x00, 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0xC3, 0x18, 0x51, 0x8C, 0x00, 0x00, 0x20, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0xDA, 0xDE, 0xFF, 0xFF, + 0xFE, 0xFF, 0xF6, 0xBD, 0xFE, 0xFF, 0xFF, 0xFF, 0x20, 0x00, 0x00, 0x00, 0xB9, 0xD6, 0x07, 0x42, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x1B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xDB, 0xDE, 0x1C, 0xE7, 0x79, 0xCE, 0xDB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x5D, 0xEF, + 0xF7, 0xBD, 0x59, 0xCE, 0x6D, 0x6B, 0xF7, 0xBD, 0xBA, 0xD6, 0xFB, 0xDE, 0x59, 0xCE, 0xBA, 0xD6, + 0xBE, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, 0x20, 0x00, 0xD7, 0xBD, 0x38, 0xC6, 0xEB, 0x5A, 0xD7, 0xBD, + 0x69, 0x4A, 0x00, 0x00, 0x1B, 0xE7, 0x07, 0x42, 0x00, 0x00, 0x4D, 0x6B, 0x00, 0x00, 0x20, 0x00, + 0x9A, 0xD6, 0xFB, 0xDE, 0x38, 0xC6, 0xBA, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0xD7, 0xBD, 0x59, 0xCE, 0x30, 0x84, 0xF7, 0xBD, 0xBA, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x3C, 0xE7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xDB, 0xDE, 0x18, 0xC6, 0xDB, 0xDE, 0x59, 0xCE, 0xC3, 0x18, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, + 0xDB, 0xDE, 0x59, 0xCE, 0xDB, 0xDE, 0x79, 0xCE, 0x49, 0x4A, 0x00, 0x00, 0x0C, 0x63, 0x00, 0x00, + 0xF2, 0x9C, 0xFF, 0xFF, 0x0F, 0x84, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCA, 0x5A, 0xDD, 0xFF, 0xA6, 0x31, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x79, 0xCE, 0xCF, 0x7B, 0x00, 0x00, 0x51, 0x8C, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0x92, 0x94, 0x00, 0x00, 0xD3, 0x9C, 0x00, 0x00, + 0x00, 0x00, 0x1B, 0xE7, 0x00, 0x00, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x99, 0xD6, 0x00, 0x00, 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0x7C, 0xEF, 0x17, 0xC6, 0x13, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xCE, 0x7B, 0xFF, 0xFF, 0x17, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x5C, 0xEF, 0xFE, 0xFF, 0x74, 0xAD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCE, 0x7B, 0xBD, 0xF7, 0xF2, 0x9C, 0x99, 0xD6, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x99, 0xD6, 0xF3, 0x9C, 0xBD, 0xF7, 0xEF, 0x7B, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, + 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xEF, 0x7B, 0xFF, 0xFF, 0x1B, 0xE7, + 0xE3, 0x18, 0x34, 0xA5, 0x00, 0x00, 0x49, 0x4A, 0xF7, 0xBD, 0x79, 0xCE, 0xB6, 0xB5, 0x38, 0xC6, + 0x00, 0x00, 0x20, 0x00, 0xC2, 0x18, 0x00, 0x00, 0x30, 0x84, 0xD7, 0xBD, 0x65, 0x29, 0x75, 0xAD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x34, 0xA5, 0x00, 0x00, 0x7C, 0xEF, 0xC7, 0x39, 0x00, 0x00, 0xCF, 0x7B, 0x00, 0x00, 0x65, 0x29, + 0xFF, 0xFF, 0x54, 0xAD, 0xFF, 0xFF, 0x3B, 0xE7, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, + 0xDB, 0xDE, 0x3C, 0xE7, 0x9A, 0xD6, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, + 0x59, 0xCE, 0xDB, 0xDE, 0x18, 0xC6, 0x9A, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xB6, 0xB5, 0x59, 0xCE, 0x75, 0xAD, 0x18, 0xC6, 0xBA, 0xD6, 0x3C, 0xE7, 0x79, 0xCE, 0xFB, 0xDE, + 0x10, 0x84, 0xB6, 0xB5, 0x08, 0x42, 0x75, 0xAD, 0x59, 0xCE, 0xDB, 0xDE, 0x18, 0xC6, 0x9A, 0xD6, + 0x7D, 0xEF, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, + 0x9E, 0xF7, 0x7D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0xFB, 0xDE, + 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, + 0x3C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, 0xDB, 0xDE, 0x1C, 0xE7, 0x1C, 0xE7, 0xBA, 0xD6, 0x9A, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, + 0xFB, 0xDE, 0xFB, 0xDE, 0x9A, 0xD6, 0x9A, 0xD6, 0xFB, 0xDE, 0x1C, 0xE7, 0x9A, 0xD6, 0x9A, 0xD6, + 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0x9E, 0xF7, + 0x1C, 0xE7, 0x3C, 0xE7, 0xBA, 0xD6, 0xDB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0x1C, 0xE7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x5D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, 0x6D, 0x6B, + 0x3C, 0xE7, 0x79, 0xCE, 0x1C, 0xE7, 0x49, 0x4A, 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x7D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0xFB, 0xDE, 0x3C, 0xE7, 0x1C, 0xE7, 0xDB, 0xDE, 0xBA, 0xD6, + 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, + 0x1C, 0xE7, 0x1C, 0xE7, 0xBA, 0xD6, 0x9A, 0xD6, 0x1C, 0xE7, 0x1C, 0xE7, 0x9A, 0xD6, 0x9A, 0xD6, + 0x38, 0xC6, 0x51, 0x8C, 0x82, 0x10, 0x00, 0x00, 0x0C, 0x63, 0x8A, 0x52, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x8D, 0x73, 0x99, 0xD6, 0x08, 0x42, 0xCA, 0x5A, 0x9D, 0xF7, 0xDD, 0xFF, + 0x69, 0x4A, 0x8A, 0x52, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x63, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, + 0xEB, 0x5A, 0xAA, 0x52, 0xDD, 0xFF, 0xBD, 0xF7, 0xE7, 0x39, 0x00, 0x00, 0x9C, 0xF7, 0x1B, 0xE7, + 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, + 0x1C, 0xE7, 0x1C, 0xE7, 0xBA, 0xD6, 0xBA, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0xFB, 0xDE, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x5D, 0xEF, 0x7D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x5D, 0xEF, + 0xF3, 0x9C, 0xD7, 0xBD, 0x00, 0x00, 0xA2, 0x10, 0x59, 0xCE, 0x79, 0xCE, 0xC7, 0x39, 0x8E, 0x73, + 0x00, 0x00, 0x00, 0x00, 0x37, 0xC6, 0xD2, 0x9C, 0x00, 0x00, 0x00, 0x00, 0xCA, 0x5A, 0x00, 0x00, + 0x9A, 0xD6, 0xBA, 0xD6, 0x55, 0xAD, 0x38, 0xC6, 0xDB, 0xDE, 0xFB, 0xDE, 0x79, 0xCE, 0x9A, 0xD6, + 0x41, 0x08, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x10, 0x84, 0xD7, 0xBD, 0x00, 0x00, 0xE3, 0x18, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x1C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x5D, 0xEF, + 0x38, 0xC6, 0x79, 0xCE, 0x4D, 0x6B, 0xB6, 0xB5, 0xBA, 0xD6, 0xFB, 0xDE, 0x38, 0xC6, 0x79, 0xCE, + 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x5D, 0xEF, 0xBA, 0xD6, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, + 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, 0x9A, 0xD6, 0xF3, 0x9C, 0x00, 0x00, 0xD3, 0x9C, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0xB2, 0x94, 0x00, 0x00, 0x30, 0x84, 0x00, 0x00, + 0x00, 0x00, 0x37, 0xC6, 0x00, 0x00, 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x99, 0xD6, 0x00, 0x00, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0x79, 0xCE, 0xDB, 0xDE, 0x79, 0xCE, 0x8E, 0x73, 0x00, 0x00, 0x8A, 0x52, 0x00, 0x00, + 0xDB, 0xDE, 0x59, 0xCE, 0xBA, 0xD6, 0x96, 0xB5, 0x65, 0x29, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, + 0x61, 0x08, 0x3B, 0xE7, 0x48, 0x4A, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCE, 0x7B, 0xFE, 0xFF, 0x34, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xB2, 0x94, 0xFF, 0xFF, 0x17, 0xC6, 0xDA, 0xDE, 0xFF, 0xFF, 0x95, 0xB5, 0xFF, 0xFF, + 0xFF, 0xFF, 0x1B, 0xE7, 0xFE, 0xFF, 0xBD, 0xF7, 0x71, 0x8C, 0xFE, 0xFF, 0x0F, 0x84, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x91, 0x94, 0x1B, 0xE7, 0x74, 0xAD, 0x78, 0xCE, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x37, 0xC6, 0x95, 0xB5, 0xFA, 0xDE, 0xB2, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0x00, 0x00, 0x58, 0xCE, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xC6, 0x39, 0xFE, 0xFF, 0x0F, 0x84, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFA, 0xDE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0x82, 0x10, 0xF3, 0x9C, 0x00, 0x00, 0x8E, 0x73, 0xD7, 0xBD, 0x79, 0xCE, 0x96, 0xB5, 0x38, 0xC6, + 0x00, 0x00, 0x08, 0x42, 0x00, 0x00, 0xC3, 0x18, 0x75, 0xAD, 0x18, 0xC6, 0x14, 0xA5, 0xD7, 0xBD, + 0xDB, 0xDE, 0x5D, 0xEF, 0xBA, 0xD6, 0x3C, 0xE7, 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0x9A, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xFB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x9E, 0xF7, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x8C, 0xB6, 0xB5, 0x2C, 0x63, 0x75, 0xAD, + 0x28, 0x42, 0x00, 0x00, 0xEE, 0x7B, 0x00, 0x00, 0x08, 0x42, 0x55, 0xAD, 0x04, 0x21, 0x34, 0xA5, + 0x38, 0xC6, 0xDB, 0xDE, 0x18, 0xC6, 0x9A, 0xD6, 0x1C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0xF7, 0xBD, 0x79, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, 0xDB, 0xDE, 0x3C, 0xE7, 0xBA, 0xD6, 0x1C, 0xE7, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, + 0x5D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x3C, 0xE7, 0x5D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0xFB, 0xDE, + 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0x1C, 0xE7, 0xDB, 0xDE, + 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, 0x38, 0xC6, 0x9A, 0xD6, 0xF3, 0x9C, 0xEB, 0x5A, 0x20, 0x00, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x9E, 0xF7, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, + 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, + 0xDB, 0xDE, 0xBA, 0xD6, 0xF7, 0xBD, 0x4D, 0x6B, 0x18, 0xC6, 0xCF, 0x7B, 0xC3, 0x18, 0x00, 0x00, + 0xFB, 0xDE, 0xBA, 0xD6, 0x9A, 0xD6, 0xEF, 0x7B, 0x18, 0xC6, 0x4D, 0x6B, 0xC3, 0x18, 0x00, 0x00, + 0x86, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x37, 0xC6, + 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8D, 0x73, 0x58, 0xCE, + 0x8D, 0x73, 0x98, 0xD6, 0xDE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0xDB, 0xDE, 0x9A, 0xD6, 0x14, 0xA5, 0xBA, 0xD6, 0x59, 0xCE, 0xEB, 0x5A, 0x04, 0x21, + 0x65, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0xEF, 0x7B, + 0x55, 0xAD, 0xEF, 0x7B, 0x20, 0x00, 0x00, 0x00, 0xEB, 0x5A, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0xFA, 0xDE, 0x28, 0x42, 0x2C, 0x63, 0x9D, 0xF7, 0xDE, 0xFF, + 0xEB, 0x5A, 0x95, 0xB5, 0xBD, 0xF7, 0xFF, 0xFF, 0x5B, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0xDE, 0xFF, + 0xC7, 0x39, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, 0xEB, 0x5A, 0x00, 0x00, 0x00, 0x00, + 0xCE, 0x7B, 0xCE, 0x7B, 0xFE, 0xFF, 0xFE, 0xFF, 0x0B, 0x63, 0xE7, 0x39, 0xDE, 0xFF, 0x9C, 0xF7, + 0x10, 0x84, 0x96, 0xB5, 0x00, 0x00, 0x41, 0x08, 0x79, 0xCE, 0x9A, 0xD6, 0x08, 0x42, 0x14, 0xA5, + 0x00, 0x00, 0x00, 0x00, 0xB9, 0xD6, 0xD2, 0x9C, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xD9, 0xDE, 0x07, 0x42, 0xFF, 0xFF, 0x70, 0x8C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDD, 0xFF, 0x0B, 0x63, 0x99, 0xD6, 0x00, 0x00, + 0xDB, 0xDE, 0x1C, 0xE7, 0x79, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0x8E, 0x73, 0x59, 0xCE, 0x00, 0x00, 0x51, 0x8C, 0xBA, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, + 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x5D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x00, 0x00, 0xC7, 0x39, 0x00, 0x00, 0x24, 0x21, 0x18, 0xC6, 0x9A, 0xD6, 0xD7, 0xBD, 0x79, 0xCE, + 0x00, 0x00, 0xA6, 0x31, 0x00, 0x00, 0x0C, 0x63, 0xB6, 0xB5, 0x59, 0xCE, 0x96, 0xB5, 0x38, 0xC6, + 0xFB, 0xDE, 0x5D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x3C, 0xE7, 0xBA, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, + 0x18, 0xC6, 0x41, 0x08, 0x18, 0xC6, 0x41, 0x08, 0x00, 0x00, 0x91, 0x94, 0x00, 0x00, 0xF3, 0x9C, + 0xDB, 0xDE, 0x28, 0x42, 0xDB, 0xDE, 0x96, 0xB5, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x10, 0x84, 0x00, 0x00, 0x18, 0xC6, 0x69, 0x4A, + 0x1C, 0xE7, 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0x34, 0xA5, 0x79, 0xCE, 0xF7, 0xBD, + 0xDE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x58, 0xCE, 0xFF, 0xFF, 0xC6, 0x39, 0x5B, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x58, 0xCE, 0x99, 0xD6, + 0x00, 0x00, 0x0F, 0x84, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, + 0x82, 0x10, 0x00, 0x00, 0x49, 0x4A, 0x00, 0x00, 0x2F, 0x84, 0xFE, 0xFF, 0xC6, 0x39, 0x7C, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0x54, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xDA, 0xDE, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x13, 0xA5, 0x28, 0x42, 0xFF, 0xFF, 0x9D, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x17, 0xC6, 0x2C, 0x63, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x91, 0x94, 0x7C, 0xEF, 0x58, 0xCE, 0x6D, 0x6B, 0xFF, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xFF, 0xFF, + 0xFF, 0xFF, 0x5B, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, 0xCE, 0x7B, 0xD6, 0xBD, 0xDD, 0xFF, 0xB1, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x13, 0xA5, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x6B, 0xF7, 0xBD, 0x00, 0x00, 0x45, 0x29, + 0x37, 0xC6, 0xEB, 0x5A, 0xFF, 0xFF, 0xBD, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x74, 0xAD, 0x00, 0x00, + 0x38, 0xC6, 0x9A, 0xD6, 0xB2, 0x94, 0x18, 0xC6, 0xDB, 0xDE, 0x1C, 0xE7, 0x79, 0xCE, 0xBA, 0xD6, + 0x41, 0x08, 0x6D, 0x6B, 0x00, 0x00, 0x00, 0x00, 0xF7, 0xBD, 0x59, 0xCE, 0x69, 0x4A, 0xD7, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x69, 0x4A, 0x00, 0x00, 0x5C, 0xEF, 0x6D, 0x6B, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, 0xCE, 0x7B, 0x00, 0x00, 0xBD, 0xF7, 0xEF, 0x7B, + 0x5D, 0xEF, 0x7D, 0xEF, 0xFB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, + 0x9A, 0xD6, 0xFB, 0xDE, 0x38, 0xC6, 0x9A, 0xD6, 0x1C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0x1C, 0xE7, + 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, + 0x5D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, 0xDB, 0xDE, 0x9A, 0xD6, + 0x96, 0xB5, 0x18, 0xC6, 0xC7, 0x39, 0x75, 0xAD, 0x59, 0xCE, 0xBA, 0xD6, 0xF7, 0xBD, 0x38, 0xC6, + 0x00, 0x00, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x75, 0xAD, 0xD7, 0xBD, 0xE7, 0x39, 0x55, 0xAD, + 0xBA, 0xD6, 0xBA, 0xD6, 0x59, 0xCE, 0x79, 0xCE, 0x79, 0xCE, 0x38, 0xC6, 0x38, 0xC6, 0x55, 0xAD, + 0xF7, 0xBD, 0xF7, 0xBD, 0x75, 0xAD, 0x96, 0xB5, 0xD7, 0xBD, 0x4D, 0x6B, 0x75, 0xAD, 0x45, 0x29, + 0x9A, 0xD6, 0x10, 0x84, 0x79, 0xCE, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, + 0xB6, 0xB5, 0x82, 0x10, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, 0xB2, 0x94, 0x00, 0x00, 0x99, 0xD6, + 0x99, 0xD6, 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xC7, 0x39, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, 0x69, 0x4A, 0xBD, 0xF7, 0x13, 0xA5, 0xFF, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x63, 0xDA, 0xDE, 0xFF, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0x50, 0x8C, 0xBD, 0xF7, 0xEF, 0x7B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x70, 0x8C, 0xFE, 0xFF, 0x91, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x13, 0xA5, 0xFF, 0xFF, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xF6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x7C, 0xEF, 0xFE, 0xFF, 0x1A, 0xE7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0xFF, 0xFF, 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x00, 0x00, 0x58, 0xCE, 0x00, 0x00, 0x61, 0x08, 0x92, 0x94, 0x00, 0x00, 0xCF, 0x7B, + 0x1A, 0xE7, 0x00, 0x00, 0x5C, 0xEF, 0x45, 0x29, 0x00, 0x00, 0x0C, 0x63, 0x00, 0x00, 0x69, 0x4A, + 0x96, 0xB5, 0x18, 0xC6, 0x55, 0xAD, 0xF7, 0xBD, 0x79, 0xCE, 0xDB, 0xDE, 0x38, 0xC6, 0x9A, 0xD6, + 0x14, 0xA5, 0x96, 0xB5, 0xD3, 0x9C, 0x55, 0xAD, 0xD7, 0xBD, 0x38, 0xC6, 0x96, 0xB5, 0xD7, 0xBD, + 0x9D, 0xF7, 0x48, 0x4A, 0xBD, 0xF7, 0x69, 0x4A, 0x00, 0x00, 0x28, 0x42, 0x00, 0x00, 0xE7, 0x39, + 0x9D, 0xF7, 0x28, 0x42, 0x5C, 0xEF, 0x65, 0x29, 0x00, 0x00, 0x08, 0x42, 0x00, 0x00, 0x65, 0x29, + 0x92, 0x94, 0xF3, 0x9C, 0x30, 0x84, 0x71, 0x8C, 0x14, 0xA5, 0xCB, 0x5A, 0xA6, 0x31, 0x00, 0x00, + 0xAE, 0x73, 0x04, 0x21, 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, + 0xDB, 0xDE, 0xFB, 0xDE, 0x9A, 0xD6, 0x9A, 0xD6, 0xBA, 0xD6, 0x9A, 0xD6, 0x59, 0xCE, 0x2C, 0x63, + 0x38, 0xC6, 0x75, 0xAD, 0x10, 0x84, 0x82, 0x10, 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xD3, 0x9C, 0x24, 0x21, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, + 0x00, 0x00, 0xA2, 0x10, 0x4C, 0x6B, 0x1A, 0xE7, 0xB5, 0xB5, 0xDE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x29, 0x00, 0x00, 0x13, 0xA5, 0x37, 0xC6, 0xFE, 0xFF, + 0x0B, 0x63, 0x1B, 0xE7, 0x9D, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xA2, 0x10, 0x74, 0xAD, 0x1B, 0xE7, 0xFF, 0xFF, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x37, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0xF2, 0x9C, 0xB2, 0x94, + 0xFF, 0xFF, 0xBD, 0xF7, 0xFA, 0xDE, 0x8D, 0x73, 0xB2, 0x94, 0x91, 0x94, 0x17, 0xC6, 0xFE, 0xFF, + 0xAE, 0x73, 0x1B, 0xE7, 0xBD, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0x78, 0xCE, 0xEE, 0x7B, + 0x5C, 0xEF, 0x71, 0x8C, 0x8D, 0x73, 0x78, 0xCE, 0x91, 0x94, 0x5B, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, + 0x58, 0xCE, 0x54, 0xAD, 0xB5, 0xB5, 0xBD, 0xF7, 0x1B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9C, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x99, 0xD6, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDE, 0xFF, 0x8D, 0x73, 0x58, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0x49, 0x4A, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD9, 0xDE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD2, 0x9C, 0x9D, 0xF7, 0x48, 0x4A, + 0x8D, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x51, 0x8C, 0x49, 0x4A, 0xD3, 0x9C, + 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, 0x65, 0x29, 0xEF, 0x7B, 0x14, 0xA5, 0xB2, 0x94, 0x55, 0xAD, + 0x61, 0x08, 0xB2, 0x94, 0x28, 0x42, 0x34, 0xA5, 0xB6, 0xB5, 0x59, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, + 0x51, 0x8C, 0x55, 0xAD, 0xF3, 0x9C, 0x96, 0xB5, 0xF7, 0xBD, 0x79, 0xCE, 0x18, 0xC6, 0xBA, 0xD6, + 0xBA, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFB, 0xDE, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x34, 0xA5, 0xD7, 0xBD, 0x75, 0xAD, 0x18, 0xC6, 0x59, 0xCE, 0xDB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, + 0xB6, 0xB5, 0x38, 0xC6, 0xF7, 0xBD, 0x79, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, + 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9A, 0xD6, 0x18, 0xC6, 0xBA, 0xD6, 0x59, 0xCE, + 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0x9A, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0xBA, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, + 0xCF, 0x7B, 0x00, 0x00, 0xB2, 0x94, 0x20, 0x00, 0x00, 0x00, 0xDA, 0xDE, 0x00, 0x00, 0x17, 0xC6, + 0x34, 0xA5, 0x41, 0x08, 0x96, 0xB5, 0x61, 0x08, 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0xB6, 0xB5, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x96, 0xB5, 0x61, 0x08, 0x96, 0xB5, 0x61, 0x08, 0x00, 0x00, 0xD6, 0xBD, 0x00, 0x00, 0xF6, 0xBD, + 0x75, 0xAD, 0x41, 0x08, 0x55, 0xAD, 0x41, 0x08, 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0xF6, 0xBD, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x91, 0x94, 0xFE, 0xFF, 0xB5, 0xB5, 0xDD, 0xFF, 0xFE, 0xFF, 0x30, 0x84, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0x30, 0x84, 0xFF, 0xFF, 0xD6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDD, 0xFF, 0xFE, 0xFF, 0x70, 0x8C, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x75, 0xAD, 0xD2, 0x9C, 0xFE, 0xFF, 0xF2, 0x9C, 0xFE, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0xFF, 0xFF, + 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x0F, 0x84, 0x78, 0xCE, 0x7C, 0xEF, 0x6D, 0x6B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xAE, 0x73, 0x00, 0x00, 0x9C, 0xF7, 0x2C, 0x63, 0x00, 0x00, 0x28, 0x42, 0x00, 0x00, 0x20, 0x00, + 0xFF, 0xFF, 0x5C, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, 0x89, 0x52, 0x00, 0x00, 0xFA, 0xDE, 0x65, 0x29, + 0xF3, 0x9C, 0x14, 0xA5, 0x8A, 0x52, 0x92, 0x94, 0x30, 0x84, 0x20, 0x00, 0x8A, 0x52, 0x00, 0x00, + 0x00, 0x00, 0xCB, 0x5A, 0x00, 0x00, 0x20, 0x00, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xB5, 0xB5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x4A, + 0xFE, 0xFF, 0x71, 0x8C, 0xFF, 0xFF, 0x9C, 0xF7, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x00, 0x00, + 0x00, 0x00, 0x74, 0xAD, 0x00, 0x00, 0x1A, 0xE7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x4C, 0x6B, 0xDE, 0xFF, 0x74, 0xAD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFA, 0xDE, 0xFF, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xFF, 0xFF, 0xA6, 0x31, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0x17, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x54, 0xAD, 0xFE, 0xFF, 0x91, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x50, 0x8C, 0xDD, 0xFF, 0x74, 0xAD, + 0xB6, 0xB5, 0xFF, 0xFF, 0xB6, 0xB5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD6, 0xBD, 0xFF, 0xFF, 0xF7, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0x99, 0xD6, 0xFF, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9C, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, + 0x3B, 0xE7, 0x00, 0x00, 0x1A, 0xE7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x99, 0xD6, 0x00, 0x00, 0xF7, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB5, 0xB5, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x95, 0xB5, 0x13, 0xA5, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xB6, 0xB5, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0x69, 0x4A, 0xBD, 0xF7, 0x8D, 0x73, 0xFE, 0xFF, + 0x0B, 0x63, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, 0xB2, 0x94, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0x30, 0x84, 0x91, 0x94, 0xD6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x99, 0xD6, 0x3B, 0xE7, 0x6D, 0x6B, + 0xFE, 0xFF, 0x13, 0xA5, 0xD6, 0xBD, 0xB1, 0x94, 0x54, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xEE, 0x7B, 0xDD, 0xFF, 0x7C, 0xEF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0x50, 0x8C, 0x0F, 0x84, 0xF6, 0xBD, 0x75, 0xAD, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0x54, 0xAD, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xAD, 0x73, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, + 0x00, 0x00, 0xEB, 0x5A, 0x41, 0x08, 0x10, 0x84, 0xF3, 0x9C, 0x96, 0xB5, 0x34, 0xA5, 0xD7, 0xBD, + 0x04, 0x21, 0xB2, 0x94, 0x28, 0x42, 0xF3, 0x9C, 0x55, 0xAD, 0xF7, 0xBD, 0x96, 0xB5, 0x38, 0xC6, + 0xFF, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, 0x13, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x08, + 0xDE, 0xFF, 0x0B, 0x63, 0x1B, 0xE7, 0x00, 0x00, 0x00, 0x00, 0x45, 0x29, 0x00, 0x00, 0x69, 0x4A, + 0x4D, 0x6B, 0x14, 0xA5, 0x51, 0x8C, 0x55, 0xAD, 0xB6, 0xB5, 0x59, 0xCE, 0xF7, 0xBD, 0x79, 0xCE, + 0xD3, 0x9C, 0x75, 0xAD, 0x14, 0xA5, 0xB6, 0xB5, 0x18, 0xC6, 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, + 0x18, 0xC6, 0xBA, 0xD6, 0x59, 0xCE, 0xDB, 0xDE, 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, + 0x79, 0xCE, 0xFB, 0xDE, 0xBA, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDB, 0xDE, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0xBA, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xBA, 0xD6, 0x3C, 0xE7, 0xBA, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, + 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, + 0x55, 0xAD, 0x41, 0x08, 0x34, 0xA5, 0x20, 0x00, 0x00, 0x00, 0x17, 0xC6, 0x00, 0x00, 0x17, 0xC6, + 0x34, 0xA5, 0x20, 0x00, 0x55, 0xAD, 0x41, 0x08, 0x00, 0x00, 0x17, 0xC6, 0x00, 0x00, 0xF6, 0xBD, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x96, 0xB5, 0x41, 0x08, 0xD7, 0xBD, 0x82, 0x10, 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0x74, 0xAD, + 0x18, 0xC6, 0xE3, 0x18, 0x59, 0xCE, 0x65, 0x29, 0x00, 0x00, 0xB2, 0x94, 0x00, 0x00, 0x30, 0x84, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x0F, 0x84, 0xDE, 0xFF, 0x54, 0xAD, 0x74, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xDE, 0xFF, 0xCE, 0x7B, 0xFF, 0xFF, 0x1A, 0xE7, 0xFA, 0xDE, 0xFF, 0xFF, 0xCE, 0x7B, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x74, 0xAD, 0x95, 0xB5, 0xDD, 0xFF, 0xAE, 0x73, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0xFF, 0xFF, 0x13, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x3B, 0xE7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x50, 0x8C, 0xFE, 0xFF, 0xB1, 0x94, 0x78, 0xCE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x58, 0xCE, 0xFF, 0xFF, + 0x89, 0x52, 0x00, 0x00, 0x37, 0xC6, 0x00, 0x00, 0xCA, 0x5A, 0xBD, 0xF7, 0x00, 0x00, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xAE, 0x73, 0xFF, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x30, 0x84, 0x00, 0x00, 0xFA, 0xDE, 0x00, 0x00, + 0x7C, 0xEF, 0xFE, 0xFF, 0x34, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x65, 0x29, 0x5C, 0xEF, 0x00, 0x00, 0x33, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFD, 0xF7, 0xFD, 0xFF, 0xFD, 0xFF, 0xFD, 0xF7, 0xFD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x9C, 0xEF, 0x77, 0xCE, + 0xFD, 0xFF, 0x56, 0xC6, 0x77, 0xC6, 0x00, 0x00, 0xC6, 0x39, 0x00, 0x00, 0xE8, 0x5A, 0x52, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFF, 0xFF, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x50, 0x8C, 0xFE, 0xFF, 0x70, 0x8C, + 0xFF, 0xFF, 0xFE, 0xFF, 0xD5, 0xBD, 0xD5, 0xBD, 0xFE, 0xFF, 0xFE, 0xFF, 0x36, 0xC6, 0x19, 0xE7, + 0x00, 0x00, 0x00, 0x00, 0x14, 0xDF, 0x14, 0xDF, 0x00, 0x00, 0x00, 0x00, 0xB2, 0xD6, 0xAF, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xBC, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x48, 0x4A, 0x11, 0xA5, 0xCA, 0x73, 0x00, 0x00, 0x3A, 0xE7, 0xFE, 0xFF, 0x00, 0x00, 0x93, 0xB5, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x31, 0xB9, 0xD6, 0xFF, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, + 0x00, 0x00, 0x4C, 0x6B, 0x00, 0x00, 0x13, 0xA5, 0xDE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, + 0x58, 0xCE, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xDC, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x17, 0xC6, 0xDD, 0xFF, 0x58, 0xCE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xDD, 0xFF, 0xFF, 0xFF, 0x13, 0xA5, 0xCE, 0x7B, 0xDA, 0xDE, 0xB5, 0xB5, 0xFF, 0xFF, + 0x99, 0xD6, 0x30, 0x84, 0xCE, 0x7B, 0x5B, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x5C, 0xEF, 0xFF, 0xFF, 0xF6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xAE, 0x73, 0x1B, 0xE7, 0x00, 0x00, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0x13, 0xA5, 0x00, 0x00, 0xC7, 0x39, 0x00, 0x00, + 0xD6, 0xBD, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, 0x00, 0x00, 0xCF, 0x7B, 0xC3, 0x18, 0xB2, 0x94, + 0xE3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x42, 0xF3, 0x9C, 0x8E, 0x73, 0x34, 0xA5, + 0x34, 0xA5, 0xD7, 0xBD, 0x75, 0xAD, 0x18, 0xC6, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, + 0x96, 0xB5, 0x38, 0xC6, 0xD7, 0xBD, 0x79, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, 0x5D, 0xEF, + 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, 0x28, 0x42, 0xB2, 0x94, 0x75, 0xAD, 0xF3, 0x9C, 0x96, 0xB5, + 0x20, 0x00, 0xEF, 0x7B, 0x45, 0x29, 0xD3, 0x9C, 0x34, 0xA5, 0xD7, 0xBD, 0x75, 0xAD, 0x18, 0xC6, + 0xF7, 0xBD, 0x9A, 0xD6, 0x38, 0xC6, 0xBA, 0xD6, 0xFB, 0xDE, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, + 0x59, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, + 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0xFB, 0xDE, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, + 0x59, 0xCE, 0x08, 0x42, 0x79, 0xCE, 0x0C, 0x63, 0x00, 0x00, 0x0B, 0x63, 0x00, 0x00, 0xC6, 0x39, + 0x9A, 0xD6, 0x10, 0x84, 0x9A, 0xD6, 0x34, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0xDD, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0xFF, 0xFF, 0xB5, 0xB5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, 0x79, 0xCE, 0x24, 0x21, 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, 0xDB, 0xDE, 0x14, 0xA5, 0x20, 0x00, 0x38, 0xC6, 0x49, 0x4A, + 0xAE, 0x73, 0xFE, 0xFF, 0x00, 0x00, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x71, 0x8C, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x37, 0xC6, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x5C, 0xEF, 0xAE, 0x73, 0xFF, 0xFF, 0x95, 0xB5, 0xBD, 0xF7, 0xFE, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, + 0xFE, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x13, 0xA5, 0xBD, 0xF7, 0x7C, 0xEF, 0x9D, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x91, 0x94, 0xFE, 0xFF, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xF2, 0x9C, 0x99, 0xD6, 0xBC, 0xEF, 0xFE, 0xFF, 0xFD, 0xF7, 0xFD, 0xF7, 0xFC, 0xF7, + 0xFE, 0xFF, 0xFD, 0xF7, 0xFD, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFB, 0xF7, 0xFB, 0xF7, 0xFB, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFC, 0xF7, 0xFD, 0xFF, 0xFC, 0xF7, + 0xFC, 0xF7, 0xFB, 0xF7, 0xFC, 0xF7, 0xFB, 0xF7, 0xFB, 0xF7, 0xB3, 0xAD, 0x38, 0xD7, 0xC6, 0x39, + 0xFB, 0xF7, 0xFB, 0xF7, 0xFB, 0xF7, 0x59, 0xDF, 0x8F, 0x8C, 0x31, 0x95, 0x48, 0x42, 0x99, 0xDF, + 0xFD, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFB, 0xF7, 0xFC, 0xF7, 0xDB, 0xEF, 0xFA, 0xEF, 0x37, 0xD7, + 0xFB, 0xEF, 0x11, 0x9D, 0xD0, 0x94, 0x2B, 0x5B, 0x31, 0x9D, 0x16, 0xCF, 0x98, 0xDF, 0xF5, 0xCE, + 0x2A, 0x5B, 0x25, 0x42, 0x00, 0x00, 0x6E, 0xA5, 0x75, 0xE7, 0xF6, 0xFF, 0xF5, 0xF7, 0xF3, 0xF7, + 0x00, 0x00, 0x0F, 0xB6, 0x00, 0x00, 0x2F, 0xB6, 0xF3, 0xF7, 0xF2, 0xF7, 0xF3, 0xEF, 0xF0, 0xF7, + 0xEA, 0x52, 0xB9, 0xDF, 0x17, 0xCF, 0xFA, 0xEF, 0xFA, 0xEF, 0x15, 0xCF, 0xFA, 0xE7, 0x97, 0xD7, + 0xFB, 0xEF, 0x54, 0xB6, 0x37, 0xCF, 0x85, 0x29, 0x92, 0x9D, 0xF8, 0xE7, 0xB5, 0xBE, 0xF9, 0xE7, + 0x00, 0x00, 0xAD, 0xA5, 0xC5, 0x31, 0x09, 0x74, 0xF2, 0xEF, 0xF0, 0xEF, 0xF1, 0xE7, 0xF0, 0xEF, + 0xAD, 0x84, 0x00, 0x00, 0xF3, 0xBE, 0x00, 0x00, 0x30, 0xCF, 0xF0, 0xEF, 0x69, 0x7C, 0xF0, 0xE7, + 0xF5, 0xF7, 0xF4, 0xFF, 0xF2, 0xF7, 0x70, 0xE7, 0xF4, 0xFF, 0xF5, 0xFF, 0x0D, 0xBE, 0x0D, 0xBE, + 0x0E, 0xD7, 0x03, 0x3A, 0xE9, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0xC6, 0xEA, 0xD6, + 0xF5, 0xFF, 0xF3, 0xDE, 0x10, 0xDF, 0xF3, 0xFF, 0xEA, 0x7B, 0x00, 0x00, 0xF4, 0xF7, 0x8F, 0xAD, + 0x00, 0x00, 0x89, 0x8C, 0xC7, 0x94, 0x00, 0x00, 0x91, 0xEF, 0xF5, 0xFF, 0x06, 0x5B, 0x71, 0xE7, + 0x68, 0x84, 0xC1, 0x31, 0x89, 0xA5, 0x00, 0x00, 0xCA, 0xEF, 0xEA, 0xFF, 0xE8, 0xD6, 0xE8, 0xF7, + 0x0C, 0xCF, 0x00, 0x00, 0xEF, 0xE7, 0xE8, 0x8C, 0xA5, 0x8C, 0xE9, 0xF7, 0x00, 0x00, 0xC7, 0xAD, + 0xEB, 0xF7, 0x29, 0xBE, 0xE8, 0xF7, 0xEB, 0xFF, 0x00, 0x00, 0xA7, 0x6B, 0xC8, 0xB5, 0x00, 0x00, + 0xE8, 0xF7, 0x69, 0xE7, 0xEA, 0xF7, 0x48, 0xBE, 0xEC, 0xF7, 0xE6, 0x7B, 0x2B, 0xDF, 0xEC, 0xD6, + 0xED, 0x7B, 0x7B, 0xEF, 0x00, 0x00, 0xEA, 0x5A, 0xFE, 0xFF, 0xFE, 0xFF, 0x7B, 0xEF, 0xFE, 0xFF, + 0x51, 0xC6, 0x00, 0x00, 0xF5, 0xFF, 0x51, 0xC6, 0x6C, 0x6B, 0xBC, 0xF7, 0x00, 0x00, 0x12, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD2, 0xEF, 0xF6, 0xFF, 0x6C, 0xA5, 0xF5, 0xFF, 0x6F, 0xAD, 0x00, 0x00, 0xD6, 0xF7, 0xC7, 0x52, + 0x00, 0x00, 0x52, 0xDF, 0x00, 0x00, 0x6D, 0xA5, 0xF7, 0xFF, 0x12, 0xBE, 0xF6, 0xFF, 0x77, 0xE7, + 0x3A, 0xE7, 0xFF, 0xFF, 0x33, 0xA5, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xEB, 0x5A, 0xDD, 0xFF, 0xC9, 0x52, 0x9C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x5C, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xF6, 0xBD, + 0xFF, 0xFF, 0x54, 0xAD, 0x3B, 0xE7, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x21, + 0x30, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x73, 0xC7, 0x39, 0xD3, 0x9C, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x5C, 0xEF, 0xFA, 0xDE, 0xA2, 0x10, 0x89, 0x52, 0x00, 0x00, + 0x9C, 0xF7, 0x4C, 0x6B, 0x4C, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x39, + 0x00, 0x00, 0xA2, 0x10, 0x20, 0x00, 0x6D, 0x6B, 0x71, 0x8C, 0x34, 0xA5, 0x14, 0xA5, 0x96, 0xB5, + 0x8A, 0x52, 0xF3, 0x9C, 0xD3, 0x9C, 0x55, 0xAD, 0x75, 0xAD, 0xF7, 0xBD, 0xD7, 0xBD, 0x59, 0xCE, + 0x4D, 0x6B, 0x34, 0xA5, 0xD3, 0x9C, 0x75, 0xAD, 0xB6, 0xB5, 0x59, 0xCE, 0xF7, 0xBD, 0x9A, 0xD6, + 0x34, 0xA5, 0xB6, 0xB5, 0x75, 0xAD, 0xF7, 0xBD, 0x38, 0xC6, 0xBA, 0xD6, 0x79, 0xCE, 0xFB, 0xDE, + 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0xD7, 0xBD, 0x59, 0xCE, 0x18, 0xC6, 0x9A, 0xD6, 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, + 0x79, 0xCE, 0xDB, 0xDE, 0xBA, 0xD6, 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0x1C, 0xE7, 0x79, 0xCE, 0x55, 0xAD, 0xBA, 0xD6, 0x59, 0xCE, + 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xFB, 0xDE, 0x9A, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, + 0x82, 0x10, 0x00, 0x00, 0x10, 0x84, 0x20, 0x00, 0x03, 0x21, 0xD9, 0xDE, 0x00, 0x00, 0x85, 0x31, + 0x18, 0xC6, 0x6D, 0x6B, 0x79, 0xCE, 0xF7, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x73, 0x20, 0x00, + 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x59, 0xCE, 0x1C, 0xE7, 0xBA, 0xD6, 0xF7, 0xBD, 0x30, 0x84, 0x59, 0xCE, 0xF7, 0xBD, + 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xBA, 0xD6, 0x59, 0xCE, 0x1C, 0xE7, 0xDB, 0xDE, + 0xFF, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0x5C, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xC3, 0x18, 0x00, 0x00, 0x34, 0xA5, 0x08, 0x42, 0x00, 0x00, 0x86, 0x31, 0x00, 0x00, 0x00, 0x00, + 0xF7, 0xBD, 0xB6, 0xB5, 0x79, 0xCE, 0x38, 0xC6, 0xEF, 0x7B, 0x04, 0x21, 0xD7, 0xBD, 0x75, 0xAD, + 0x95, 0xB5, 0x9D, 0xF7, 0x00, 0x00, 0x89, 0x52, 0xFF, 0xFF, 0xFE, 0xFF, 0xD6, 0xBD, 0x9C, 0xF7, + 0x00, 0x00, 0x00, 0x00, 0x4D, 0x6B, 0xE3, 0x18, 0x00, 0x00, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x33, 0xA5, 0x1A, 0xE7, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0x8D, 0x73, 0x95, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFA, 0xDE, 0xDD, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0x37, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x1B, 0xE7, + 0xBD, 0xF7, 0x37, 0xC6, 0xEB, 0x5A, 0x00, 0x00, 0xAD, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0xEF, 0x7B, 0x9D, 0xF7, 0xFA, 0xDE, 0x28, 0x42, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x8D, 0x73, 0x00, 0x00, 0x00, 0x00, 0x54, 0xAD, 0x58, 0xCE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFB, 0xF7, 0xFD, 0xFF, 0xFB, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, 0xFF, 0xFC, 0xF7, 0xFC, 0xFF, 0xFC, 0xF7, + 0xFB, 0xF7, 0xF4, 0xB5, 0xFB, 0xF7, 0x2E, 0x7C, 0x4E, 0x7C, 0xFA, 0xE7, 0x55, 0xB6, 0x14, 0xB6, + 0xDB, 0xEF, 0x2B, 0x5B, 0xBA, 0xE7, 0x4B, 0x63, 0xB6, 0xC6, 0x0A, 0x5B, 0xB3, 0xAD, 0xCC, 0x6B, + 0x17, 0xC6, 0x3B, 0xE7, 0x00, 0x00, 0xEB, 0x5A, 0xFD, 0xFF, 0xFC, 0xF7, 0xDC, 0xF7, 0xFC, 0xFF, + 0x00, 0x00, 0xB1, 0x94, 0x3B, 0xE7, 0xFE, 0xFF, 0xFD, 0xFF, 0xFC, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, + 0x59, 0xDF, 0x2B, 0x63, 0x59, 0xE7, 0xED, 0x73, 0x90, 0x8C, 0x92, 0xA5, 0xCD, 0x73, 0x11, 0x95, + 0xFC, 0xF7, 0x9A, 0xE7, 0xFC, 0xF7, 0xFC, 0xF7, 0xED, 0x73, 0x89, 0x4A, 0x18, 0xD7, 0x28, 0x42, + 0x4B, 0x63, 0xD2, 0xA5, 0x8B, 0x63, 0xF9, 0xE7, 0xF9, 0xE7, 0xF9, 0xDF, 0x77, 0xCF, 0xF5, 0xBE, + 0xF6, 0xC6, 0x78, 0xD7, 0x99, 0xDF, 0x0A, 0x5B, 0x68, 0x42, 0xB2, 0x9D, 0x71, 0x95, 0xF9, 0xDF, + 0xF7, 0xDF, 0x0D, 0x8D, 0xF8, 0xD7, 0xB5, 0xCF, 0x00, 0x00, 0xCC, 0xA5, 0xA9, 0x63, 0x00, 0x00, + 0xF8, 0xDF, 0xF8, 0xDF, 0xD8, 0xD7, 0x33, 0xA6, 0x94, 0xCF, 0x48, 0x5B, 0xD6, 0xCF, 0xB5, 0xCF, + 0x31, 0x95, 0x6E, 0x7C, 0xA9, 0x52, 0x98, 0xD7, 0xF9, 0xE7, 0xD8, 0xD7, 0xD9, 0xDF, 0xAC, 0x63, + 0x51, 0x9D, 0xFA, 0xE7, 0x18, 0xD7, 0x72, 0x9D, 0xED, 0x73, 0x8E, 0x84, 0xCC, 0x6B, 0xFA, 0xE7, + 0x2D, 0x74, 0xAB, 0x63, 0x2D, 0x74, 0xD8, 0xD7, 0xB7, 0xCF, 0xF7, 0xD7, 0xF9, 0xDF, 0xD8, 0xD7, + 0xF9, 0xDF, 0xF9, 0xE7, 0xFA, 0xE7, 0xB5, 0xBE, 0x97, 0xCF, 0xCC, 0x6B, 0x68, 0x42, 0xCF, 0x8C, + 0xF0, 0xE7, 0xCE, 0xDF, 0x0C, 0xAE, 0xF0, 0xE7, 0x87, 0x84, 0x00, 0x00, 0xEF, 0xE7, 0x4B, 0xB6, + 0x00, 0x00, 0x2B, 0x95, 0x4B, 0x74, 0x00, 0x00, 0xB0, 0xDF, 0xF0, 0xEF, 0xC5, 0x4A, 0x4D, 0xB6, + 0xA6, 0x8C, 0x86, 0x8C, 0x47, 0x7C, 0xC8, 0x8C, 0xEA, 0xB5, 0xEF, 0xF7, 0x8E, 0xDF, 0xF1, 0xF7, + 0xF0, 0xEF, 0xF0, 0xEF, 0xB1, 0xDF, 0xF2, 0xEF, 0xF1, 0xEF, 0xF2, 0xEF, 0xF3, 0xEF, 0xF4, 0xEF, + 0xF6, 0xD7, 0x30, 0xA6, 0xD1, 0x9D, 0xB6, 0xD7, 0x46, 0x3A, 0x00, 0x00, 0xB6, 0xD7, 0x31, 0xAE, + 0xEC, 0x6B, 0xD8, 0xD7, 0xF9, 0xDF, 0xF9, 0xE7, 0xF9, 0xE7, 0xF5, 0xC6, 0x13, 0xAE, 0x66, 0x29, + 0x64, 0x42, 0xEB, 0x8C, 0xCA, 0x6B, 0x00, 0x00, 0xEF, 0xAD, 0x2D, 0x95, 0x00, 0x00, 0x00, 0x00, + 0x56, 0xCF, 0x77, 0xD7, 0x17, 0xCF, 0xFA, 0xEF, 0x16, 0xCF, 0x77, 0xD7, 0xFA, 0xEF, 0x14, 0xAE, + 0x46, 0x63, 0xA7, 0x52, 0x8C, 0xA5, 0x00, 0x00, 0xD5, 0xEF, 0xF8, 0xF7, 0x14, 0xDF, 0xF9, 0xFF, + 0x4F, 0xBE, 0x00, 0x00, 0x8E, 0xA5, 0x00, 0x00, 0xB3, 0xCE, 0xFA, 0xFF, 0xF5, 0xD6, 0xFB, 0xF7, + 0x0D, 0x7C, 0x1A, 0xDF, 0x10, 0x9D, 0x3A, 0xE7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD4, 0xB5, 0x9C, 0xEF, 0x97, 0xC6, 0xDD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x4A, 0x63, 0xCC, 0x73, 0x58, 0xD7, 0xD9, 0xEF, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, + 0xFA, 0xEF, 0xFC, 0xEF, 0x59, 0xD7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, + 0x9B, 0xEF, 0xFD, 0xFF, 0xFD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xB2, 0x94, 0xBD, 0xF7, 0xA6, 0x31, + 0xFD, 0xF7, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x89, 0x52, 0x50, 0x8C, 0x00, 0x00, 0x00, 0x00, 0x95, 0xB5, 0xB9, 0xD6, 0x00, 0x00, 0x00, 0x00, + 0xD2, 0x9C, 0x6D, 0x6B, 0xFF, 0xFF, 0xFE, 0xFF, 0x86, 0x31, 0x00, 0x00, 0x7C, 0xEF, 0x99, 0xD6, + 0x9C, 0xF7, 0x9D, 0xF7, 0x07, 0x42, 0x28, 0x42, 0x78, 0xCE, 0x50, 0x8C, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x54, 0xAD, 0x8D, 0x73, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0x5B, 0xEF, 0x95, 0xB5, 0xBD, 0xF7, 0xF6, 0xBD, 0xAA, 0x52, 0x00, 0x00, + 0xFE, 0xFF, 0xFF, 0xFF, 0xBD, 0xF7, 0x54, 0xAD, 0xDA, 0xDE, 0x89, 0x52, 0x00, 0x00, 0x00, 0x00, + 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x21, 0x6D, 0x6B, + 0x03, 0x21, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x28, 0x42, + 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, 0x4D, 0x6B, 0x00, 0x00, 0x61, 0x08, + 0xA2, 0x10, 0x69, 0x4A, 0x8E, 0x73, 0x10, 0x84, 0x30, 0x84, 0xB2, 0x94, 0x71, 0x8C, 0xF3, 0x9C, + 0xCF, 0x7B, 0x10, 0x84, 0x86, 0x31, 0x2C, 0x63, 0x92, 0x94, 0xF3, 0x9C, 0x92, 0x94, 0x14, 0xA5, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xE7, 0x39, 0xC7, 0x39, 0xD3, 0x9C, 0xD3, 0x9C, 0x34, 0xA5, + 0x8A, 0x52, 0xD3, 0x9C, 0xD3, 0x9C, 0x34, 0xA5, 0x34, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, 0x18, 0xC6, + 0x34, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, 0x38, 0xC6, 0x38, 0xC6, 0xBA, 0xD6, 0x9A, 0xD6, 0xFB, 0xDE, + 0x18, 0xC6, 0x9A, 0xD6, 0x79, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, 0x3C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, + 0x14, 0xA5, 0x96, 0xB5, 0x55, 0xAD, 0xD7, 0xBD, 0xF7, 0xBD, 0x59, 0xCE, 0x38, 0xC6, 0xBA, 0xD6, + 0x75, 0xAD, 0xD7, 0xBD, 0x75, 0xAD, 0xF7, 0xBD, 0x59, 0xCE, 0xBA, 0xD6, 0x59, 0xCE, 0xBA, 0xD6, + 0xBA, 0xD6, 0x1C, 0xE7, 0xFB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFB, 0xDE, 0x3C, 0xE7, 0xFB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, + 0xFB, 0xDE, 0x5D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x7D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDB, 0xDE, 0x9A, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x7D, 0xEF, 0xFB, 0xDE, 0xBA, 0xD6, 0x5D, 0xEF, 0x1C, 0xE7, + 0x96, 0xB5, 0x34, 0xA5, 0x18, 0xC6, 0xB6, 0xB5, 0x6D, 0x6B, 0x45, 0x29, 0x55, 0xAD, 0xF3, 0x9C, + 0x79, 0xCE, 0x18, 0xC6, 0xBA, 0xD6, 0x59, 0xCE, 0xB6, 0xB5, 0x34, 0xA5, 0xF7, 0xBD, 0x75, 0xAD, + 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, + 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0xFB, 0xDE, 0x1C, 0xE7, 0xDB, 0xDE, + 0xBA, 0xD6, 0x79, 0xCE, 0xDB, 0xDE, 0x79, 0xCE, 0xF7, 0xBD, 0x34, 0xA5, 0x34, 0xA5, 0x04, 0x21, + 0x9A, 0xD6, 0x14, 0xA5, 0x14, 0xA5, 0x82, 0x10, 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0xCF, 0x7B, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x20, 0x00, + 0xD3, 0x9C, 0x51, 0x8C, 0x14, 0xA5, 0x49, 0x4A, 0xCB, 0x5A, 0x41, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x8C, 0xA6, 0x31, 0xB6, 0xB5, 0x5C, 0xEF, 0xFF, 0xFF, + 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x29, 0x4C, 0x6B, 0x1B, 0xE7, + 0x00, 0x00, 0x71, 0x8C, 0x54, 0xAD, 0xFE, 0xFF, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x17, 0xC6, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xEB, 0x5A, 0x37, 0xC6, 0xEB, 0x5A, 0xB5, 0xB5, 0xDD, 0xFF, 0xFF, 0xFF, + 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, + 0xFF, 0xFF, 0xDD, 0xFF, 0x99, 0xD6, 0xAE, 0x73, 0xF6, 0xBD, 0xD2, 0x9C, 0x74, 0xAD, 0xBD, 0xF7, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFC, 0xFF, 0xFC, 0xF7, 0xFD, 0xFF, 0xFC, 0xFF, 0xFB, 0xF7, 0x38, 0xDF, 0xFC, 0xF7, 0xFC, 0xFF, + 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFC, 0xFF, 0xFC, 0xF7, 0xFD, 0xFF, 0xFC, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFA, 0xDE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDD, 0xFF, 0x50, 0x8C, 0xB9, 0xD6, 0x00, 0x00, + 0xD7, 0xCE, 0x27, 0x42, 0x96, 0xC6, 0xF1, 0x94, 0x79, 0xDF, 0x58, 0xD7, 0xAF, 0x8C, 0x68, 0x4A, + 0xFC, 0xFF, 0xB7, 0xCE, 0xFC, 0xF7, 0xFC, 0xFF, 0x11, 0x95, 0x76, 0xBE, 0x79, 0xE7, 0x0B, 0x5B, + 0x8F, 0x84, 0x07, 0x3A, 0x52, 0x9D, 0xB9, 0xDF, 0x54, 0xB6, 0xFA, 0xE7, 0xFA, 0xE7, 0x34, 0xB6, + 0x96, 0xC6, 0x52, 0x9D, 0xCD, 0x73, 0x11, 0x9D, 0xC9, 0x52, 0x6B, 0x63, 0xB7, 0xCE, 0xBA, 0xE7, + 0xFC, 0xFF, 0xFC, 0xFF, 0xFD, 0xFF, 0xFD, 0xFF, 0xFC, 0xF7, 0x59, 0xE7, 0xFC, 0xFF, 0xDB, 0xF7, + 0x0F, 0x84, 0xBD, 0xF7, 0x00, 0x00, 0x1B, 0xE7, 0xFE, 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x6F, 0x84, 0x4F, 0x84, 0x15, 0xBE, 0x15, 0xBE, 0x0E, 0x7C, 0xCA, 0x52, 0x76, 0xCE, 0xF8, 0xD6, + 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD9, 0xDF, 0x10, 0x8D, 0x88, 0x4A, 0x0D, 0x7C, 0x27, 0x42, 0xF6, 0xC6, 0x78, 0xDF, 0xFB, 0xEF, + 0x96, 0xC6, 0xFB, 0xEF, 0x59, 0xDF, 0xD3, 0xAD, 0xFA, 0xE7, 0x34, 0xB6, 0x0A, 0x5B, 0x2B, 0x5B, + 0xFA, 0xEF, 0xFA, 0xE7, 0x99, 0xDF, 0xED, 0x73, 0xF0, 0x94, 0xCA, 0x52, 0x8C, 0x6B, 0x9A, 0xE7, + 0x27, 0x42, 0xD0, 0x94, 0x96, 0xC6, 0xFC, 0xF7, 0xDB, 0xEF, 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, + 0x68, 0x4A, 0x2E, 0x7C, 0x9A, 0xEF, 0xFC, 0xF7, 0x76, 0xC6, 0xDB, 0xEF, 0xFC, 0xFF, 0xFD, 0xF7, + 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x7A, 0xDF, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xFF, + 0xFC, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, + 0xFE, 0xFF, 0x16, 0xBE, 0xFE, 0xFF, 0x0F, 0x84, 0xAA, 0x52, 0x78, 0xCE, 0x00, 0x00, 0xA2, 0x10, + 0xFF, 0xFF, 0xDA, 0xDE, 0xFE, 0xFF, 0xFF, 0xFF, 0x24, 0x21, 0x00, 0x00, 0x78, 0xCE, 0x00, 0x00, + 0xFF, 0xFF, 0xFE, 0xFF, 0xDA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0x9C, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0x48, 0x4A, 0x5C, 0xEF, 0x00, 0x00, 0xCE, 0x7B, 0xFF, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x5B, 0xEF, 0x17, 0xC6, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xD2, 0x9C, 0xFF, 0xFF, 0xFE, 0xFF, 0x30, 0x84, 0xD2, 0x9C, 0x9D, 0xF7, 0xDA, 0xDE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0x1B, 0xE7, 0xD6, 0xBD, 0x71, 0x8C, 0xDE, 0xFF, 0xFF, 0xFF, 0x0F, 0x84, 0x33, 0xA5, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9C, 0xF7, 0x78, 0xCE, 0xFE, 0xFF, 0xFF, 0xFF, + 0x50, 0x8C, 0xE7, 0x39, 0xFE, 0xFF, 0x9C, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x58, 0xCE, 0x50, 0x8C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, 0xC3, 0x18, 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, + 0x7C, 0xEF, 0xD6, 0xBD, 0xFE, 0xFF, 0xFF, 0xFF, 0x4C, 0x6B, 0x00, 0x00, 0xDE, 0xFF, 0x99, 0xD6, + 0xFF, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xD2, 0x9C, 0xCE, 0x7B, 0xFF, 0xFF, 0xBD, 0xF7, 0x33, 0xA5, 0xFA, 0xDE, 0x58, 0xCE, 0x50, 0x8C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0xDA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD3, 0x9C, 0x96, 0xB5, 0x61, 0x08, 0x8A, 0x52, 0xF7, 0xBD, 0x59, 0xCE, 0x34, 0xA5, 0x18, 0xC6, + 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, 0x82, 0x10, 0x0C, 0x63, 0x00, 0x00, 0x00, 0x00, + 0xBA, 0xD6, 0xFB, 0xDE, 0x59, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0x3C, 0xE7, + 0xB6, 0xB5, 0x38, 0xC6, 0x24, 0x21, 0x92, 0x94, 0x79, 0xCE, 0xDB, 0xDE, 0x18, 0xC6, 0x79, 0xCE, + 0xFE, 0xFF, 0x99, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, 0x2C, 0x63, 0x00, 0x00, 0xDD, 0xFF, 0x95, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x63, 0xF7, 0xBD, 0x00, 0x00, 0x28, 0x42, + 0xDA, 0xDE, 0xAA, 0x52, 0xFF, 0xFF, 0x7C, 0xEF, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, + 0x9E, 0xF7, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x5D, 0xEF, 0xBA, 0xD6, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x38, 0xC6, 0x9A, 0xD6, 0xB6, 0xB5, 0x38, 0xC6, 0xFB, 0xDE, 0x3C, 0xE7, 0x9A, 0xD6, 0xFB, 0xDE, + 0xA6, 0x31, 0x96, 0xB5, 0x00, 0x00, 0xA6, 0x31, 0x18, 0xC6, 0x9A, 0xD6, 0x96, 0xB5, 0x38, 0xC6, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, + 0xDB, 0xDE, 0x3C, 0xE7, 0x9A, 0xD6, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, + 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0xBA, 0xD6, 0xFB, 0xDE, 0x79, 0xCE, + 0x7D, 0xEF, 0x3C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, 0xDB, 0xDE, 0x96, 0xB5, 0x79, 0xCE, 0x45, 0x29, + 0x1C, 0xE7, 0xDB, 0xDE, 0xFB, 0xDE, 0xB6, 0xB5, 0x2C, 0x63, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, + 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0xD6, 0xBD, 0xFF, 0xFF, + 0x00, 0x00, 0x54, 0xAD, 0x8D, 0x73, 0xDE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBA, 0xD6, 0xCB, 0x5A, 0xD7, 0xBD, 0x61, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, + 0x4D, 0x6B, 0x00, 0x00, 0x04, 0x21, 0x00, 0x00, 0x00, 0x00, 0xB9, 0xD6, 0x6D, 0x6B, 0xFE, 0xFF, + 0xB9, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x5B, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0x7C, 0xEF, 0x8D, 0x73, 0xCE, 0x7B, 0x99, 0xD6, + 0xFE, 0xFF, 0x91, 0x94, 0xB5, 0xB5, 0xF3, 0x9C, 0xF6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9C, 0xF7, 0xDD, 0xFF, 0x13, 0xA5, 0x0F, 0x84, 0x95, 0xB5, + 0x5B, 0xEF, 0x8D, 0x73, 0x6D, 0x6B, 0xD9, 0xDE, 0x78, 0xCE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x50, 0x8C, 0x3B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x54, 0xAD, 0x00, 0x00, 0x8D, 0x73, 0x00, 0x00, + 0xFE, 0xFF, 0x7C, 0xEF, 0xFF, 0xFF, 0x1A, 0xE7, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, 0x17, 0xC6, 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, 0x48, 0x4A, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, 0x00, 0x00, 0x89, 0x52, 0x00, 0x00, 0xCA, 0x5A, + 0x89, 0x52, 0xBD, 0xF7, 0x91, 0x94, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0xFF, 0xFF, 0xDA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0xBD, 0xF7, 0xFE, 0xFF, 0x74, 0xAD, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0x13, 0xA5, 0xFF, 0xFF, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x17, 0xC6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xB2, 0x94, 0x3B, 0xE7, 0x5B, 0xEF, 0xB2, 0x94, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x95, 0xB5, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0x34, 0xA5, 0xFE, 0xFF, 0x00, 0x00, 0x99, 0xD6, + 0x7C, 0xEF, 0x69, 0x4A, 0xFF, 0xFF, 0x78, 0xCE, 0x00, 0x00, 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF2, 0x9C, 0x00, 0x00, 0x9C, 0xF7, 0x69, 0x4A, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x37, 0xC6, 0xFE, 0xFF, 0xDE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9D, 0xF7, 0xFE, 0xFF, 0xD2, 0x9C, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xB9, 0xD6, 0x00, 0x00, 0x8D, 0x73, 0xFF, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x6D, 0x6B, 0x00, 0x00, 0x37, 0xC6, 0xFF, 0xFF, 0x2B, 0x63, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFA, 0xDE, 0x50, 0x8C, 0xFF, 0xFF, 0xFE, 0xFF, 0xB2, 0x94, 0x7C, 0xEF, 0x58, 0xCE, 0x8D, 0x73, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x30, 0x84, 0x54, 0xAD, 0xFE, 0xFF, 0x34, 0xA5, 0xFE, 0xFF, 0xFE, 0xFF, 0x71, 0x8C, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0x2F, 0x84, 0xFF, 0xFF, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0x0F, 0x84, 0xFF, 0xFF, 0x37, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFF, 0xFF, 0xEF, 0x7B, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xB2, 0x94, 0xFF, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, 0xFE, 0xFF, 0x17, 0xC6, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xEF, 0x7B, 0x00, 0x00, 0x08, 0x42, 0xB6, 0xB5, 0x00, 0x00, 0xCB, 0x5A, + 0x9C, 0xF7, 0x0B, 0x63, 0xFF, 0xFF, 0x1A, 0xE7, 0x00, 0x00, 0x20, 0x00, 0x04, 0x21, 0x00, 0x00, + 0x38, 0xC6, 0x9A, 0xD6, 0xB6, 0xB5, 0x38, 0xC6, 0xFB, 0xDE, 0x5D, 0xEF, 0xBA, 0xD6, 0x1C, 0xE7, + 0xEF, 0x7B, 0xD7, 0xBD, 0xC3, 0x18, 0x34, 0xA5, 0x59, 0xCE, 0xDB, 0xDE, 0xF7, 0xBD, 0x79, 0xCE, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0x00, 0x00, 0xFE, 0xFF, 0xEE, 0x7B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x69, 0x4A, 0x00, 0x00, 0x20, 0x00, 0x96, 0xB5, 0x38, 0xC6, 0x71, 0x8C, 0xD7, 0xBD, + 0x00, 0x00, 0x00, 0x00, 0xB2, 0x94, 0x00, 0x00, 0xC7, 0x39, 0x96, 0xB5, 0x20, 0x00, 0x30, 0x84, + 0x7D, 0xEF, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9A, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0x18, 0xC6, 0x9A, 0xD6, 0xD7, 0xBD, 0x59, 0xCE, 0xFB, 0xDE, 0x5D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, 0xDB, 0xDE, 0xD3, 0x9C, 0xBA, 0xD6, 0xEB, 0x5A, + 0x5D, 0xEF, 0xFB, 0xDE, 0x3C, 0xE7, 0xFB, 0xDE, 0x79, 0xCE, 0x24, 0x21, 0x96, 0xB5, 0x41, 0x08, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0x3C, 0xE7, 0xDB, 0xDE, 0x1C, 0xE7, 0xBA, 0xD6, 0x71, 0x8C, 0x00, 0x00, 0x6D, 0x6B, 0x00, 0x00, + 0x1C, 0xE7, 0xBA, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0x8A, 0x52, 0x00, 0x00, 0x08, 0x42, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x29, 0xF6, 0xBD, 0xFF, 0xFF, 0x5C, 0xEF, 0xFE, 0xFF, + 0x00, 0x00, 0xEE, 0x7B, 0x00, 0x00, 0x95, 0xB5, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xB9, 0xD6, 0x45, 0x29, 0x5C, 0xEF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xAA, 0x52, 0xBD, 0xF7, 0x2C, 0x63, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xDE, 0xFF, 0xEF, 0x7B, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xF6, 0xBD, 0x33, 0xA5, 0x50, 0x8C, 0xBD, 0xF7, + 0xCE, 0x7B, 0xDD, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xDE, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, 0x00, 0x00, 0xCA, 0x5A, 0x00, 0x00, 0xAA, 0x52, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0x37, 0xC6, 0x00, 0x00, 0x89, 0x52, 0x00, 0x00, 0x28, 0x42, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3B, 0xE7, 0xBD, 0xF7, 0xD2, 0x9C, 0x6D, 0x6B, 0x00, 0x00, + 0xFF, 0xFF, 0x75, 0xAD, 0xB5, 0xB5, 0x00, 0x00, 0x00, 0x00, 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, + 0xDD, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0xFF, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xFF, 0xFF, 0x33, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFE, 0xFF, 0xDE, 0xFF, 0x37, 0xC6, 0xFF, 0xFF, 0x91, 0x94, 0x9D, 0xF7, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x99, 0xD6, 0x95, 0xB5, 0xFE, 0xFF, 0xD2, 0x9C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0xFF, 0xFF, 0xF2, 0x9C, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0x75, 0xAD, 0xFE, 0xFF, 0xD2, 0x9C, 0xFF, 0xFF, 0xFE, 0xFF, 0x9C, 0xF7, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x78, 0xCE, 0x00, 0x00, 0xDE, 0xFF, 0x4C, 0x6B, 0x00, 0x00, 0x58, 0xCE, 0x00, 0x00, 0xEE, 0x7B, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFE, 0xFF, 0x7C, 0xEF, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x31, 0x00, 0x00, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xFF, 0xFF, 0x00, 0x00, 0x17, 0xC6, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x71, 0x8C, 0x00, 0x00, 0x37, 0xC6, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0x45, 0x29, 0xFE, 0xFF, 0xAE, 0x73, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0xFE, 0xFF, 0x00, 0x00, 0x74, 0xAD, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x91, 0x94, 0x9D, 0xF7, 0x00, 0x00, 0xCA, 0x5A, 0xFF, 0xFF, 0xFE, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFA, 0xDE, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0x61, 0x08, 0xFE, 0xFF, 0x91, 0x94, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x41, 0x08, + 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x37, 0xC6, 0x00, 0x00, 0x5C, 0xEF, 0x04, 0x21, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x7C, 0xEF, 0xC7, 0x39, 0xDA, 0xDE, 0x00, 0x00, + 0x75, 0xAD, 0x18, 0xC6, 0x92, 0x94, 0xD7, 0xBD, 0x9A, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, + 0x69, 0x4A, 0x96, 0xB5, 0xA2, 0x10, 0x34, 0xA5, 0x38, 0xC6, 0xBA, 0xD6, 0xF7, 0xBD, 0x9A, 0xD6, + 0x5D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x9E, 0xF7, 0xBE, 0xF7, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x00, 0x00, 0xEF, 0x7B, 0x00, 0x00, 0xEB, 0x5A, 0xD7, 0xBD, 0x79, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, + 0x00, 0x00, 0xAA, 0x52, 0x00, 0x00, 0x4D, 0x6B, 0xB6, 0xB5, 0x59, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, + 0xDB, 0xDE, 0x5D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0xE7, 0x39, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0x49, 0x4A, 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0x1C, 0xE7, 0x9A, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, 0xEF, 0x7B, 0x00, 0x00, 0x14, 0xA5, 0x20, 0x00, + 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, 0x18, 0xC6, 0xE3, 0x18, 0x59, 0xCE, 0x69, 0x4A, + 0x8D, 0x73, 0xFE, 0xFF, 0x6D, 0x6B, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xEB, 0x5A, 0xDD, 0xFF, 0xE7, 0x39, 0x9C, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xFA, 0xDE, 0x00, 0x00, 0xF6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x30, 0x84, 0x00, 0x00, 0xC6, 0x39, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xBD, 0xF7, 0x54, 0xAD, 0xEB, 0x5A, 0x00, 0x00, + 0xFE, 0xFF, 0xFF, 0xFF, 0x7C, 0xEF, 0xB6, 0xB5, 0xDE, 0xFF, 0xFA, 0xDE, 0x4C, 0x6B, 0x00, 0x00, + 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x49, 0x4A, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDA, 0xDE, 0xF2, 0x9C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x3B, 0xE7, 0x50, 0x8C, + 0x7C, 0xEF, 0x54, 0xAD, 0xA6, 0x31, 0x00, 0x00, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x74, 0xAD, 0x2C, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x20, 0x00, 0x04, 0x21, 0xCF, 0x7B, 0xB2, 0x94, 0x8A, 0x52, 0x10, 0x84, 0xF3, 0x9C, 0x34, 0xA5, + 0x00, 0x00, 0x00, 0x00, 0x65, 0x29, 0x6D, 0x6B, 0x24, 0x21, 0x6D, 0x6B, 0xD3, 0x9C, 0x14, 0xA5, + 0xF3, 0x9C, 0x34, 0xA5, 0x75, 0xAD, 0xB6, 0xB5, 0x75, 0xAD, 0xB6, 0xB5, 0xF7, 0xBD, 0x59, 0xCE, + 0x17, 0xC6, 0x85, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x39, + 0x00, 0x00, 0x82, 0x10, 0xA6, 0x31, 0x30, 0x84, 0x0C, 0x63, 0x71, 0x8C, 0xB2, 0x94, 0xF3, 0x9C, + 0x04, 0x21, 0x4D, 0x6B, 0xEF, 0x7B, 0xEF, 0x7B, 0x45, 0x29, 0x00, 0x00, 0x49, 0x4A, 0x00, 0x00, + 0x71, 0x8C, 0x92, 0x94, 0xF3, 0x9C, 0x14, 0xA5, 0xAE, 0x73, 0x00, 0x00, 0xD3, 0x9C, 0x04, 0x21, + 0xD3, 0x9C, 0x14, 0xA5, 0x75, 0xAD, 0xB6, 0xB5, 0x55, 0xAD, 0x96, 0xB5, 0xD7, 0xBD, 0x18, 0xC6, + 0xF7, 0xBD, 0x38, 0xC6, 0x79, 0xCE, 0xBA, 0xD6, 0x59, 0xCE, 0x9A, 0xD6, 0xDB, 0xDE, 0xFB, 0xDE, + 0x96, 0xB5, 0x96, 0xB5, 0x18, 0xC6, 0x18, 0xC6, 0x55, 0xAD, 0xEB, 0x5A, 0xD7, 0xBD, 0xF3, 0x9C, + 0x79, 0xCE, 0x79, 0xCE, 0xFB, 0xDE, 0xDB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0x9A, 0xD6, 0x59, 0xCE, + 0x8D, 0x73, 0xFE, 0xFF, 0x24, 0x21, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x17, 0xC6, 0x00, 0x00, 0xCE, 0x7B, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0xFA, 0xDE, 0xFF, 0xFF, 0x91, 0x94, 0xFE, 0xFF, + 0x8A, 0x52, 0x00, 0x00, 0x55, 0xAD, 0x82, 0x10, 0x00, 0x00, 0xB9, 0xD6, 0x00, 0x00, 0x0B, 0x63, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, 0xDD, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0xB2, 0x94, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xD6, 0xBD, 0xB9, 0xD6, 0x5B, 0xEF, 0x13, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF3, 0x9C, 0xFF, 0xFF, 0x98, 0xD6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0x7C, 0xEF, 0xFE, 0xFF, 0x99, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xB9, 0xD6, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x74, 0xAD, 0xFF, 0xFF, 0x99, 0xD6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xDE, 0xFF, + 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x04, 0x21, 0xAA, 0x52, 0x6D, 0x6B, + 0x85, 0x31, 0x00, 0x00, 0x4C, 0x6B, 0x00, 0x00, 0x08, 0x42, 0xAE, 0x73, 0x65, 0x29, 0xEF, 0x7B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xB1, 0x94, 0x00, 0x00, 0xB6, 0xB5, 0x00, 0x00, 0xE3, 0x18, 0x30, 0x84, 0x61, 0x08, 0x10, 0x84, + 0x99, 0xD6, 0x00, 0x00, 0x3B, 0xE7, 0x00, 0x00, 0x00, 0x00, 0xAE, 0x73, 0x00, 0x00, 0x2C, 0x63, + 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, 0x41, 0x08, 0x00, 0x00, 0x30, 0x84, 0x00, 0x00, 0x00, 0x00, + 0xEF, 0x7B, 0xAE, 0x73, 0x51, 0x8C, 0x92, 0x94, 0xC7, 0x39, 0x41, 0x08, 0x92, 0x94, 0x30, 0x84, + 0xDA, 0xDE, 0xFE, 0xFF, 0x00, 0x00, 0xAD, 0x73, 0xFF, 0xFF, 0xFF, 0xFF, 0xD6, 0xBD, 0x1A, 0xE7, + 0x00, 0x00, 0x00, 0x00, 0x69, 0x4A, 0xE3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x92, 0x94, 0xD3, 0x9C, 0xD3, 0x9C, 0x34, 0xA5, 0x14, 0xA5, 0x34, 0xA5, 0x75, 0xAD, 0xB6, 0xB5, + 0xF3, 0x9C, 0x75, 0xAD, 0x14, 0xA5, 0x96, 0xB5, 0xB6, 0xB5, 0x18, 0xC6, 0xF7, 0xBD, 0x59, 0xCE, + 0x34, 0xA5, 0x14, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, 0x30, 0x84, 0x2C, 0x63, 0xB6, 0xB5, 0x96, 0xB5, + 0x18, 0xC6, 0x38, 0xC6, 0x9A, 0xD6, 0xBA, 0xD6, 0x38, 0xC6, 0x38, 0xC6, 0xBA, 0xD6, 0xBA, 0xD6, + 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xDD, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xBD, 0xF7, 0x5B, 0xEF, + 0x28, 0x42, 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x52, 0xE3, 0x18, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xBD, 0xF7, 0xB6, 0xB5, 0xCA, 0x5A, 0x78, 0xCE, 0xD2, 0x9C, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, 0x61, 0x08, 0xAA, 0x52, 0x30, 0x84, + 0x69, 0x4A, 0x08, 0x42, 0x96, 0xB5, 0x75, 0xAD, 0x08, 0x42, 0xAA, 0x52, 0x75, 0xAD, 0x75, 0xAD, + 0x18, 0xC6, 0x18, 0xC6, 0xBA, 0xD6, 0x9A, 0xD6, 0x18, 0xC6, 0x18, 0xC6, 0x9A, 0xD6, 0x9A, 0xD6, + 0xCF, 0x7B, 0xD3, 0x9C, 0x75, 0xAD, 0x96, 0xB5, 0x14, 0xA5, 0x14, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, + 0x18, 0xC6, 0x38, 0xC6, 0xBA, 0xD6, 0xBA, 0xD6, 0x38, 0xC6, 0x59, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, + 0xCE, 0x7B, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, 0x33, 0xA5, 0xB9, 0xD6, 0x00, 0x00, 0x00, 0x00, + 0x24, 0x21, 0x04, 0x21, 0x92, 0x94, 0xB2, 0x94, 0x41, 0x08, 0x00, 0x00, 0x30, 0x84, 0x4D, 0x6B, + 0x9D, 0xF7, 0xBD, 0xF7, 0x08, 0x42, 0x48, 0x4A, 0x2F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x49, 0x4A, 0x28, 0x42, 0x00, 0x00, 0x65, 0x29, 0x4D, 0x6B, 0x55, 0xAD, + 0x34, 0xA5, 0x55, 0xAD, 0xD7, 0xBD, 0xF7, 0xBD, 0x55, 0xAD, 0x75, 0xAD, 0xF7, 0xBD, 0x18, 0xC6, + 0x79, 0xCE, 0x79, 0xCE, 0xFB, 0xDE, 0xFB, 0xDE, 0x9A, 0xD6, 0x9A, 0xD6, 0x1C, 0xE7, 0x1C, 0xE7, + 0x96, 0xB5, 0x96, 0xB5, 0x18, 0xC6, 0x38, 0xC6, 0xD7, 0xBD, 0xF7, 0xBD, 0x59, 0xCE, 0x79, 0xCE, + 0x9A, 0xD6, 0xBA, 0xD6, 0x1C, 0xE7, 0x3C, 0xE7, 0xDB, 0xDE, 0xFB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, + 0x41, 0x08, 0xB2, 0x94, 0x28, 0x42, 0x96, 0xB5, 0xD7, 0xBD, 0x79, 0xCE, 0x18, 0xC6, 0x9A, 0xD6, + 0x34, 0xA5, 0xD7, 0xBD, 0xD7, 0xBD, 0x38, 0xC6, 0x59, 0xCE, 0xBA, 0xD6, 0x9A, 0xD6, 0xFB, 0xDE, + 0xDB, 0xDE, 0x5D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x59, 0xCE, 0x9A, 0xD6, 0xBA, 0xD6, 0xFB, 0xDE, 0xDB, 0xDE, 0x3C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, + 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, + 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x5D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0x1C, 0xE7, 0x79, 0xCE, 0x51, 0x8C, 0xBA, 0xD6, 0xF7, 0xBD, + 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xDB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0xDB, 0xDE, 0x5D, 0xEF, 0x1C, 0xE7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, + 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, 0x17, 0xC6, 0xFF, 0xFF, 0x2C, 0x63, 0xDD, 0xFF, + 0x4D, 0x6B, 0x00, 0x00, 0xF7, 0xBD, 0x24, 0x21, 0x00, 0x00, 0x95, 0xB5, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xB5, 0xB5, 0xDA, 0xDE, 0x1B, 0xE7, 0xE7, 0x39, 0xCA, 0x5A, 0x00, 0x00, + 0x79, 0xCE, 0xD3, 0x9C, 0xBA, 0xD6, 0x59, 0xCE, 0x61, 0x08, 0x00, 0x00, 0xB2, 0x94, 0x04, 0x21, + 0xFB, 0xDE, 0xBA, 0xD6, 0x3C, 0xE7, 0x1C, 0xE7, 0x59, 0xCE, 0xD7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x8A, 0x52, + 0x51, 0x8C, 0x8E, 0x73, 0x59, 0xCE, 0x38, 0xC6, 0x92, 0x94, 0x96, 0xB5, 0x38, 0xC6, 0x38, 0xC6, + 0x99, 0xD6, 0x03, 0x21, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x49, 0x4A, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xCB, 0x5A, 0xCB, 0x5A, 0x92, 0x94, 0xB2, 0x94, 0x14, 0xA5, + 0x04, 0x21, 0x2C, 0x63, 0x71, 0x8C, 0xB2, 0x94, 0x71, 0x8C, 0xD3, 0x9C, 0x14, 0xA5, 0x75, 0xAD, + 0xF3, 0x9C, 0x55, 0xAD, 0x75, 0xAD, 0xD7, 0xBD, 0x96, 0xB5, 0xF7, 0xBD, 0x38, 0xC6, 0x79, 0xCE, + 0x8A, 0x52, 0xF3, 0x9C, 0x34, 0xA5, 0x75, 0xAD, 0x55, 0xAD, 0x96, 0xB5, 0xD7, 0xBD, 0x38, 0xC6, + 0xD7, 0xBD, 0xF7, 0xBD, 0x59, 0xCE, 0x9A, 0xD6, 0x59, 0xCE, 0x9A, 0xD6, 0xBA, 0xD6, 0xFB, 0xDE, + 0xF7, 0xBD, 0x59, 0xCE, 0x79, 0xCE, 0xDB, 0xDE, 0x9A, 0xD6, 0xDB, 0xDE, 0x1C, 0xE7, 0x5D, 0xEF, + 0xDB, 0xDE, 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, + 0x14, 0xA5, 0x55, 0xAD, 0xB6, 0xB5, 0xF7, 0xBD, 0x96, 0xB5, 0xD7, 0xBD, 0x38, 0xC6, 0x79, 0xCE, + 0x38, 0xC6, 0x79, 0xCE, 0xBA, 0xD6, 0xFB, 0xDE, 0xBA, 0xD6, 0xDB, 0xDE, 0x1C, 0xE7, 0x5D, 0xEF, + 0x18, 0xC6, 0x59, 0xCE, 0x9A, 0xD6, 0xDB, 0xDE, 0x79, 0xCE, 0xBA, 0xD6, 0xFB, 0xDE, 0x3C, 0xE7, + 0xFB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, + 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, + 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFB, 0xDE, 0x1C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, + 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0xDB, 0xDE, 0x9A, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, + 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, + 0x18, 0xC6, 0x8E, 0x73, 0x79, 0xCE, 0xF7, 0xBD, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, + 0xBA, 0xD6, 0x59, 0xCE, 0xFB, 0xDE, 0xBA, 0xD6, 0x96, 0xB5, 0x24, 0x21, 0x38, 0xC6, 0x14, 0xA5, + 0xB1, 0x94, 0xFE, 0xFF, 0x00, 0x00, 0x54, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, 0x74, 0xAD, 0xFE, 0xFF, 0x00, 0x00, 0xF2, 0x9C, + 0x3C, 0xE7, 0xFB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, 0x9A, 0xD6, 0x18, 0xC6, 0xDB, 0xDE, 0x79, 0xCE, + 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x5D, 0xEF, 0x3C, 0xE7, + 0xF3, 0x9C, 0x04, 0x21, 0x18, 0xC6, 0x34, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x86, 0x31, 0x00, 0x00, + 0x79, 0xCE, 0x18, 0xC6, 0xDB, 0xDE, 0x79, 0xCE, 0x96, 0xB5, 0x8A, 0x52, 0x18, 0xC6, 0xB6, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCE, 0x7B, 0x5B, 0xEF, 0x00, 0x00, 0xA6, 0x31, 0xFF, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0xDE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xEF, 0x7B, 0xE3, 0x18, 0x00, 0x00, 0x6D, 0x6B, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x99, 0xD6, 0xFE, 0xFF, 0x00, 0x00, 0x8D, 0x73, 0xFF, 0xFF, 0xFE, 0xFF, 0x58, 0xCE, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9D, 0xF7, 0x28, 0x42, 0xDE, 0xFF, 0x6C, 0x6B, 0x00, 0x00, 0x69, 0x4A, 0x00, 0x00, 0xC7, 0x39, + 0xFE, 0xFF, 0x70, 0x8C, 0xFF, 0xFF, 0x54, 0xAD, 0x00, 0x00, 0x24, 0x21, 0x00, 0x00, 0xA2, 0x10, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0x17, 0xC6, 0xFF, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x1B, 0xE7, 0xFE, 0xFF, 0x5C, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x44, 0x29, 0x00, 0x00, + 0x14, 0xA5, 0xB6, 0xB5, 0x14, 0xA5, 0xB6, 0xB5, 0x18, 0xC6, 0x9A, 0xD6, 0x38, 0xC6, 0xBA, 0xD6, + 0x14, 0xA5, 0xB6, 0xB5, 0xD3, 0x9C, 0xB6, 0xB5, 0x38, 0xC6, 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, + 0xDB, 0xDE, 0xFB, 0xDE, 0xFB, 0xDE, 0x3C, 0xE7, 0x1C, 0xE7, 0x1C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, + 0x1C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, + 0x71, 0x8C, 0x96, 0xB5, 0xEF, 0x7B, 0x96, 0xB5, 0x38, 0xC6, 0xBA, 0xD6, 0x18, 0xC6, 0xBA, 0xD6, + 0x8E, 0x73, 0x75, 0xAD, 0x0C, 0x63, 0x75, 0xAD, 0x18, 0xC6, 0xBA, 0xD6, 0xF7, 0xBD, 0x9A, 0xD6, + 0x1C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, + 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x1C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, + 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, + 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xFB, 0xDE, 0x7D, 0xEF, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x9A, 0xD6, 0x3C, 0xE7, 0x1C, 0xE7, 0x9A, 0xD6, 0xBA, 0xD6, 0x1C, 0xE7, 0x1C, 0xE7, + 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x5D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDB, 0xDE, 0xFB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, + 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, + 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, 0x9A, 0xD6, 0x38, 0xC6, 0xFB, 0xDE, 0xBA, 0xD6, + 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x3C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xD7, 0xBD, 0x55, 0xAD, 0x59, 0xCE, 0x18, 0xC6, 0xCB, 0x5A, 0x82, 0x10, 0xB6, 0xB5, 0xF3, 0x9C, + 0xBA, 0xD6, 0x79, 0xCE, 0x3C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xD7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0xA2, 0x10, 0x00, 0x00, 0x2C, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x96, 0xB5, 0xF3, 0x9C, 0x38, 0xC6, 0xD7, 0xBD, 0x0C, 0x63, 0xE3, 0x18, 0x96, 0xB5, 0x34, 0xA5, + 0x7D, 0xEF, 0x3C, 0xE7, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0x9A, 0xD6, 0x59, 0xCE, 0x1C, 0xE7, 0xDB, 0xDE, 0x18, 0xC6, 0xD7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x5D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, + 0x17, 0xC6, 0xBD, 0xF7, 0x00, 0x00, 0x89, 0x52, 0xFF, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0x7C, 0xEF, + 0x00, 0x00, 0x00, 0x00, 0x4D, 0x6B, 0x24, 0x21, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x5C, 0xEF, 0x00, 0x00, 0x85, 0x31, 0xFF, 0xFF, 0xFF, 0xFF, 0x13, 0xA5, 0x5C, 0xEF, + 0x96, 0xB5, 0x55, 0xAD, 0x38, 0xC6, 0xF7, 0xBD, 0xAE, 0x73, 0x45, 0x29, 0x96, 0xB5, 0x55, 0xAD, + 0x9A, 0xD6, 0x79, 0xCE, 0x1C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x00, 0x00, 0x00, 0x00, 0xCF, 0x7B, 0x86, 0x31, 0x00, 0x00, 0x45, 0x29, 0x00, 0x00, 0x00, 0x00, + 0x96, 0xB5, 0x55, 0xAD, 0x38, 0xC6, 0xF7, 0xBD, 0xEF, 0x7B, 0x65, 0x29, 0xB6, 0xB5, 0x55, 0xAD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0x48, 0x4A, 0x00, 0x00, 0x89, 0x52, 0x00, 0x00, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0x89, 0x52, 0x00, 0x00, 0x69, 0x4A, 0x00, 0x00, + 0x33, 0xA5, 0x5C, 0xEF, 0x00, 0x00, 0x86, 0x31, 0xFF, 0xFF, 0xFF, 0xFF, 0x54, 0xAD, 0x5C, 0xEF, + 0x00, 0x00, 0x00, 0x00, 0xEF, 0x7B, 0x65, 0x29, 0x00, 0x00, 0x85, 0x31, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x5B, 0xEF, 0xFF, 0xFF, 0xF7, 0xBD, 0xC3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0F, 0x84, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x21, 0x20, 0x00, 0xEF, 0x7B, + 0xCB, 0x5A, 0x55, 0xAD, 0x8A, 0x52, 0x55, 0xAD, 0xF7, 0xBD, 0x9A, 0xD6, 0xF7, 0xBD, 0x9A, 0xD6, + 0x8A, 0x52, 0x75, 0xAD, 0xCB, 0x5A, 0x75, 0xAD, 0xF7, 0xBD, 0x9A, 0xD6, 0x18, 0xC6, 0x9A, 0xD6, + 0x1C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0xFB, 0xDE, 0x7D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x4D, 0x6B, 0x96, 0xB5, 0x30, 0x84, 0xB6, 0xB5, 0x18, 0xC6, 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, + 0x75, 0xAD, 0xF7, 0xBD, 0xB6, 0xB5, 0x38, 0xC6, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, + 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x79, 0xCE, 0x1C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x5D, 0xEF, 0x3C, 0xE7, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xFB, 0xDE, 0x7D, 0xEF, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xB6, 0xB5, 0x75, 0xAD, 0x59, 0xCE, 0x18, 0xC6, 0x30, 0x84, 0x28, 0x42, 0xF7, 0xBD, 0xD7, 0xBD, + 0xBA, 0xD6, 0x9A, 0xD6, 0x3C, 0xE7, 0x1C, 0xE7, 0x79, 0xCE, 0x59, 0xCE, 0xFB, 0xDE, 0xDB, 0xDE, + 0x24, 0x21, 0x86, 0x31, 0xD7, 0xBD, 0xD7, 0xBD, 0x10, 0x84, 0xB6, 0xB5, 0x18, 0xC6, 0x38, 0xC6, + 0x59, 0xCE, 0x59, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, 0x79, 0xCE, 0x9A, 0xD6, 0xFB, 0xDE, 0x1C, 0xE7, + 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x5D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0x5D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, + 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x18, 0xC6, 0x79, 0xCE, 0x79, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, 0x3C, 0xE7, 0x1C, 0xE7, 0x5D, 0xEF, + 0xDB, 0xDE, 0x1C, 0xE7, 0x3C, 0xE7, 0x5D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x43, 0x4C, 0x49, 0x4D, 0xFF, 0xFE, 0x14, 0x00, 0x00, 0x00, 0x02, 0x02, 0x28, 0x80, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x69, 0x6D, 0x61, 0x67, 0x10, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00 +}; diff --git a/app/sources/main.cpp b/app/sources/main.cpp new file mode 100644 index 0000000..8f8cff4 --- /dev/null +++ b/app/sources/main.cpp @@ -0,0 +1,236 @@ + +#include +#include +#include "sys/stat.h" +#include +#include + +#include "Main.hpp" +#include "plgldr.h" +#include "BCLIM.hpp" +#include "logo.h" +#include "plugin.h" +#include "3gx.h" + +Logger logger; + +const char* artic_setup_plugin = "/3ds/AzaharArticSetup/AzaharArticSetup.3gx"; + +char *strdup(const char *s) { + char *d = (char*)malloc(strlen(s) + 1); + if (d == NULL) return NULL; + strcpy(d, s); + return d; +} + +FILE* fopen_mkdir(const char* name, const char* mode, bool actuallyOpen = true) +{ + char* _path = strdup(name); + char *p; + FILE* retfile = NULL; + + errno = 0; + for (p = _path + 1; *p; p++) + { + if (*p == '/') + { + *p = '\0'; + if (mkdir(_path, 777) != 0) + if (errno != EEXIST) goto error; + *p = '/'; + } + } + if (actuallyOpen) retfile = fopen(name, mode); +error: + free(_path); + return retfile; +} + +bool extractPlugin() { + u32 expectedVersion = SYSTEM_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION); + bool plugin_needs_update = true; + FILE* f = fopen(artic_setup_plugin, "r"); + if (f) { + _3gx_Header header; + int read = fread(&header, 1, sizeof(header), f); + if (read == sizeof(header) && header.magic == _3GX_MAGIC) { + plugin_needs_update = header.version != expectedVersion; + } + } + if (f) fclose(f); + + if (plugin_needs_update) { + logger.Info("Updating Azahar Artic Setup plugin file"); + f = fopen_mkdir(artic_setup_plugin, "w"); + if (!f) { + logger.Error("Cannot open plugin file"); + return false; + } + int written = fwrite(plugin_AzaharArticSetup_3gx, 1, plugin_AzaharArticSetup_3gx_size, f); + fclose(f); + if (written != plugin_AzaharArticSetup_3gx_size) { + logger.Error("Cannot write plugin file"); + return false; + } + } + return true; +} + +bool launchPlugin() { + u32 ret = 0; + PluginLoadParameters plgparam = { 0 }; + u8 isPlgEnabled = 0; + + plgparam.noFlash = true; + plgparam.pluginMemoryStrategy = PLG_STRATEGY_NONE; + plgparam.persistent = 0; + plgparam.lowTitleId = 0; + strcpy(plgparam.path, artic_setup_plugin); + + ret = plgLdrInit(); + if (R_FAILED(ret)) { + logger.Error("Cannot start plugin loader"); + return false; + } + u32 version; + ret = PLGLDR__GetVersion(&version); + if (R_FAILED(ret)) { + logger.Error("Plugin loader error"); + plgLdrExit(); + return false; + } + if (version < SYSTEM_VERSION(1,0,2)) { + logger.Error("Unsupported plugin loader version,"); + logger.Error("please update Luma3DS"); + plgLdrExit(); + return false; + } + ret = PLGLDR__IsPluginLoaderEnabled((bool*)&isPlgEnabled); + if (R_FAILED(ret)) { + logger.Error("Plugin loader error"); + plgLdrExit(); + return false; + } + plgparam.config[0] = isPlgEnabled; + ret = PLGLDR__SetPluginLoaderState(true); + if (R_FAILED(ret)) { + logger.Error("Cannot enable plugin loader"); + plgLdrExit(); + return false; + } + ret = PLGLDR__SetPluginLoadParameters(&plgparam); + plgLdrExit(); + if (R_FAILED(ret)) { + logger.Error("Plugin loader error"); + return false; + } + return true; +} + +PrintConsole topScreenConsole, bottomScreenConsole; +int transferedBytes = 0; +void Main() { + logger.Start(); + logger.debug_enable = true; + + gfxInitDefault(); + consoleInit(GFX_TOP, &topScreenConsole); + consoleInit(GFX_BOTTOM, &bottomScreenConsole); + topScreenConsole.bg = 15; topScreenConsole.fg = 0; + bottomScreenConsole.bg = 15; bottomScreenConsole.fg = 0; + + gfxSetDoubleBuffering(GFX_BOTTOM, false); + + aptSetHomeAllowed(false); + + consoleSelect(&bottomScreenConsole); + consoleClear(); + consoleSelect(&topScreenConsole); + consoleClear(); + + { + CTRPluginFramework::BCLIM((void*)__data_logo_bin, __data_logo_bin_size).Render(CTRPluginFramework::Rect((320 - 128) / 2, (240 - 128) / 2, 128, 128)); + } + logger.Raw(false, "\n Azahar Artic Setup v%d.%d.%d\n", VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION); + logger.Raw(false, " Press A to launch setup tool."); + logger.Raw(false, " Press B or START to exit."); + logger.Raw(true, ""); + logger.Info("Welcome to Azahar Artic Setup Tool!\n Only use this tool with Azahar Emulator\n\n Check bottom screen for controls."); + + bool do_jump = false; + while (aptMainLoop()) + { + //Scan all the inputs. This should be done once for each frame + hidScanInput(); + + //hidKeysDown returns information about which buttons have been just pressed (and they weren't in the previous frame) + u32 kDown = hidKeysDown(); + + if (kDown & (KEY_B | KEY_START)) { + break; + } + + if (kDown & KEY_A) { + logger.Info("Launching Azahar Artic Setup"); + bool done = extractPlugin() && launchPlugin(); + if (done) { + do_jump = true; + logger.Raw(true, ""); + logger.Info("Done! Please wait..."); + svcSleepThread(3000000000); + break; + } else { + logger.Error("Failed to launch Azahar Artic Setup"); + } + } + + // Flush and swap framebuffers + gfxFlushBuffers(); + gfxSwapBuffers(); + + //Wait for VBlank + gspWaitForVBlank(); + } + + // Flush and swap framebuffers + gfxFlushBuffers(); + gfxSwapBuffers(); + + //Wait for VBlank + gspWaitForVBlank(); + + gfxExit(); + gspLcdExit(); + logger.End(); + + if (do_jump) { + OS_VersionBin cver = {0}; + OS_VersionBin nver = {0}; + osGetSystemVersionData(&nver, &cver); + u64 program_id = 0; + if (cver.region == 'E') { + program_id = 0x0004001000022000; + } else if (cver.region == 'U') { + program_id = 0x0004001000021000; + } else if (cver.region == 'J') { + program_id = 0x0004001000020000; + } else if (cver.region == 'C') { + program_id = 0x0004001000026000; + } else if (cver.region == 'K') { + program_id = 0x0004001000027000; + } else if (cver.region == 'T') { + program_id = 0x0004001000028000; + } + aptSetChainloader(program_id, MEDIATYPE_NAND); + } +} + +extern "C" { + int main(int argc, char* argv[]); +} +// Entrypoint, game will starts when you exit this function +int main(int argc, char* argv[]) +{ + Main(); + return 0; +} diff --git a/app/sources/plgldr.c b/app/sources/plgldr.c new file mode 100644 index 0000000..6a1c3c9 --- /dev/null +++ b/app/sources/plgldr.c @@ -0,0 +1,134 @@ +#include <3ds.h> +#include "plgldr.h" +#include "csvc.h" + +static Handle plgLdrHandle = 0; +static int plgLdrRefCount; + +Result plgLdrInit(void) +{ + Result res = 0; + + if (AtomicPostIncrement(&plgLdrRefCount) == 0) + res = svcConnectToPort(&plgLdrHandle, "plg:ldr"); + + if (R_FAILED(res)) AtomicDecrement(&plgLdrRefCount); + + return res; +} + +void plgLdrExit(void) +{ + if (AtomicDecrement(&plgLdrRefCount)) + return; + svcCloseHandle(plgLdrHandle); +} + +Result PLGLDR__IsPluginLoaderEnabled(bool *isEnabled) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(2, 0, 0); + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + *isEnabled = cmdbuf[2]; + } + return res; +} + +Result PLGLDR__SetPluginLoaderState(bool enabled) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(3, 1, 0); + cmdbuf[1] = (u32)enabled; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__SetPluginLoadParameters(PluginLoadParameters *parameters) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(4, 2, 4); + cmdbuf[1] = (u32)parameters->noFlash | (((u32)parameters->pluginMemoryStrategy) << 8) | (((u32)parameters->persistent) << 16); + cmdbuf[2] = parameters->lowTitleId; + cmdbuf[3] = IPC_Desc_Buffer(256, IPC_BUFFER_R); + cmdbuf[4] = (u32)parameters->path; + cmdbuf[5] = IPC_Desc_Buffer(32 * sizeof(u32), IPC_BUFFER_R); + cmdbuf[6] = (u32)parameters->config; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__GetVersion(u32* version) +{ + Result res = 0; + + u32* cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(8, 0, 0); + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + if (cmdbuf[0] != IPC_MakeHeader(8, 2, 0)) + return 0xD900182F; + + res = cmdbuf[1]; + if (version) + *version = cmdbuf[2]; + } + return res; +} + +Result PLGLDR__SetExeDecSettings(void* decFunc, void* args) +{ + Result res = 0; + + u32 buf[0x10] = { 0 }; + u32* trueArgs; + if (args) trueArgs = args; + else trueArgs = buf; + + u32* cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(13, 1, 2); + cmdbuf[1] = (decFunc) ? svcConvertVAToPA(decFunc, false) | (1 << 31) : 0; + cmdbuf[2] = IPC_Desc_Buffer(16 * sizeof(u32), IPC_BUFFER_R); + cmdbuf[3] = (u32)trueArgs; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__ClearPluginLoadParameters() +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(14, 0, 0); + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} \ No newline at end of file diff --git a/images/logo_small.png b/images/logo_small.png new file mode 100644 index 0000000000000000000000000000000000000000..e0e8826ee65ec36d7ba7f66abccc35c12cc50a2d GIT binary patch literal 15265 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 literal 0 HcmV?d00001 diff --git a/plugin/.gitignore b/plugin/.gitignore new file mode 100644 index 0000000..a255430 --- /dev/null +++ b/plugin/.gitignore @@ -0,0 +1,3 @@ +/build +*.3gx +.vscode/ diff --git a/plugin/3gx.ld b/plugin/3gx.ld new file mode 100644 index 0000000..30560b3 --- /dev/null +++ b/plugin/3gx.ld @@ -0,0 +1,202 @@ + +OUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm", "elf32-littlearm") +OUTPUT_ARCH(arm) +ENTRY(_start) + +PHDRS +{ + code PT_LOAD FLAGS(5) /* Read | Execute */; + rodata PT_LOAD FLAGS(4) /* Read */; + data PT_LOAD FLAGS(6) /* Read | Write */; +} + +SECTIONS +{ + /* =========== CODE section =========== */ + + PROVIDE(__start__ = 0x07000100); + . = __start__; + + .text ALIGN(4) : + { + /* .init */ + KEEP( *(.crt0) ) + KEEP( *(.init) ) + . = ALIGN(4); + + /* .text */ + *(.text) + *(.text.*) + *(.glue_7) + *(.glue_7t) + *(.stub) + *(.gnu.warning) + *(.gnu.linkonce.t*) + . = ALIGN(4); + + /* .fini */ + KEEP( *(.fini) ) + . = ALIGN(4); + + } : code + __text_end__ = .; + + /* =========== RODATA section =========== */ + + .rodata ALIGN(0x4) : + { + *(.rodata) + *(.roda) + *(.rodata.*) + *all.rodata*(*) + *(.gnu.linkonce.r*) + SORT(CONSTRUCTORS) + . = ALIGN(4); + __tdata_align = .; + LONG (ALIGNOF(.tdata)); + . = ALIGN(4); + } : rodata + + .ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } : rodata + __exidx_start = .; + ARM.exidx : { *(.ARM.exidx* .gnu.linkonce.armexidx.*) } : rodata + __exidx_end = .; + + /* =========== DATA section =========== */ + + .data ALIGN(4): + { + *(.data) + *(.data.*) + *(.gnu.linkonce.d*) + CONSTRUCTORS + . = ALIGN(4); + } : data + + .tdata : ALIGN(4) + { + __tdata_lma = .; + *(.tdata) + *(.tdata.*) + *(.gnu.linkonce.td.*) + . = ALIGN(4); + __tdata_lma_end = .; + } : data + + .tbss : ALIGN(4) + { + *(.tbss) + *(.tbss.*) + *(.gnu.linkonce.tb.*) + *(.tcommon) + . = ALIGN(4); + } : data + + .preinit_array ALIGN(4) : + { + PROVIDE (__preinit_array_start = .); + KEEP (*(.preinit_array)) + PROVIDE (__preinit_array_end = .); + } : data + + .init_array ALIGN(4) : + { + PROVIDE (__init_array_start = .); + KEEP (*(SORT(.init_array.*))) + KEEP (*(.init_array)) + PROVIDE (__init_array_end = .); + } : data + + .fini_array ALIGN(4) : + { + PROVIDE (__fini_array_start = .); + KEEP (*(.fini_array)) + KEEP (*(SORT(.fini_array.*))) + PROVIDE (__fini_array_end = .); + } : data + + .ctors ALIGN(4) : + { + KEEP (*crtbegin.o(.ctors)) /* MUST be first -- GCC requires it */ + KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors)) + KEEP (*(SORT(.ctors.*))) + KEEP (*(.ctors)) + } : data + + .dtors ALIGN(4) : + { + KEEP (*crtbegin.o(.dtors)) + KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors)) + KEEP (*(SORT(.dtors.*))) + KEEP (*(.dtors)) + } : data + + __bss_start__ = .; + .bss ALIGN(4) : + { + *(.dynbss) + *(.bss) + *(.bss.*) + *(.gnu.linkonce.b*) + *(COMMON) + + /* Reserve space for the TLS segment of the main thread. + We need (__tls_start - 8) to be aligned the same as .tdata, to account for + the 8-byte ARM TLS header. Since the header is not actually used for + ARM_TLS_LE32 relocation, we just fake it by subtracting 8 from the data + offset. + */ + . = 8 + ABSOLUTE(ALIGN(ABSOLUTE(. - 8), ALIGNOF(.tdata))); + __tls_start = .; + . += SIZEOF(.tdata); + /* Ensure the alignment of .tbss is accounted for in the total size, + since SIZEOF(.tdata) doesn't include any padding before .tbss. + */ + . = ALIGN(ALIGNOF(.tbss)); + . += SIZEOF(.tbss); + __tls_end = .; + } : data + __bss_end__ = .; + + __end__ = ABSOLUTE(.) ; + + /* ================== + ==== Metadata ==== + ================== */ + + /* Discard sections that difficult post-processing */ + /DISCARD/ : { *(.group .comment .note) } + + /* Stabs debugging sections. */ + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + + /* DWARF debug sections. + Symbols in the DWARF debugging sections are relative to the beginning + of the section so we begin them at 0. */ + + /* DWARF 1 */ + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + + /* GNU DWARF 1 extensions */ + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + + /* DWARF 1.1 and DWARF 2 */ + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + + /* DWARF 2 */ + .debug_info 0 : { *(.debug_info) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } +} diff --git a/plugin/ArticProtocol b/plugin/ArticProtocol new file mode 160000 index 0000000..842ab85 --- /dev/null +++ b/plugin/ArticProtocol @@ -0,0 +1 @@ +Subproject commit 842ab851afb6e08419d1f0a94bf3450a2080a21e diff --git a/plugin/AzaharArticSetup.plgInfo b/plugin/AzaharArticSetup.plgInfo new file mode 100644 index 0000000..c81f89c --- /dev/null +++ b/plugin/AzaharArticSetup.plgInfo @@ -0,0 +1,27 @@ +Author: Nanquitas + +Version: # Plugin version + Major: VERSION_MAJOR + Minor: VERSION_MINOR + Revision: VERSION_REVISION + +Targets: # Low TitleId of games which are compatibles with this plugin (empty for all) + - 0x00020000 + - 0x00021000 + - 0x00022000 + - 0x00026000 + - 0x00027000 + - 0x00028000 + +Title: Azahar Artic Setup Tool + +Summary: Setup tool for Azahar Emulator + +Description: | + Provides system files to the Azahar 3DS Emulator + +Compatibility: Console +MemorySize: 2MiB + +EventsSelfManaged: true +SwapNotNeeded: true \ No newline at end of file diff --git a/plugin/Makefile b/plugin/Makefile new file mode 100644 index 0000000..1a0f17f --- /dev/null +++ b/plugin/Makefile @@ -0,0 +1,121 @@ +.SUFFIXES: + +ifeq ($(strip $(DEVKITARM)),) +$(error "Please set DEVKITARM in your environment. export DEVKITARM=devkitARM") +endif + +TOPDIR ?= $(CURDIR) +include $(DEVKITARM)/3ds_rules + +TARGET := AzaharArticSetup +PLGINFO := build/AzaharArticSetup.plgInfo + +BUILD := build +INCLUDES := ArticProtocol/includes includes +SOURCES := ArticProtocol/sources sources sources/CTRPluginFramework + +VERSION_MAJOR := 1 +VERSION_MINOR := 2 +VERSION_REVISION := 0 +SERVER_PORT := 5543 + +IP := 19 +FTP_HOST := 192.168.1. +FTP_PORT := "5000" +FTP_PATH := "luma/plugins" + +#--------------------------------------------------------------------------------- +# options for code generation +#--------------------------------------------------------------------------------- +ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft + +CFLAGS := $(ARCH) -Os -mword-relocations \ + -fomit-frame-pointer -ffunction-sections -fno-strict-aliasing + +CFLAGS += $(INCLUDE) -D__3DS__ -DVERSION_MAJOR=$(VERSION_MAJOR) -DVERSION_MINOR=$(VERSION_MINOR) \ + -DVERSION_REVISION=$(VERSION_REVISION) -DSERVER_PORT=$(SERVER_PORT) + +CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++20 + +ASFLAGS := $(ARCH) +LDFLAGS := -T $(TOPDIR)/3gx.ld $(ARCH) -Os -Wl,--gc-sections,--strip-discarded + +LIBS := -lctru +LIBDIRS := $(CTRULIB) $(PORTLIBS) + +#--------------------------------------------------------------------------------- +# no real need to edit anything past this point unless you need to add additional +# rules for different file extensions +#--------------------------------------------------------------------------------- +ifneq ($(BUILD),$(notdir $(CURDIR))) +#--------------------------------------------------------------------------------- + +export OUTPUT := $(CURDIR)/$(TARGET) +export TOPDIR := $(CURDIR) +export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \ + $(foreach dir,$(DATA),$(CURDIR)/$(dir)) + +export DEPSDIR := $(CURDIR)/$(BUILD) + +CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c))) +CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp))) +SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s))) + +export LD := $(CXX) +export OFILES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o) +export INCLUDE := $(foreach dir,$(INCLUDES),-I $(CURDIR)/$(dir) ) \ + $(foreach dir,$(LIBDIRS),-I $(dir)/include) \ + -I $(CURDIR)/$(BUILD) + +export LIBPATHS := $(foreach dir,$(LIBDIRS),-L $(dir)/lib) + +.PHONY: $(BUILD) clean all send + +#--------------------------------------------------------------------------------- +all: $(BUILD) + +$(BUILD): + @[ -d $@ ] || mkdir -p $@ + @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile + +#--------------------------------------------------------------------------------- +clean: + @echo clean ... + @rm -fr $(BUILD) $(OUTPUT).3gx $(OUTPUT).elf + +send: + @echo "Sending plugin over FTP" + @$(CURDIR)/sendfile.py $(TARGET).3gx $(FTP_PATH) "$(FTP_HOST)$(IP)" $(FTP_PORT) default.3gx + +re: clean all + +#--------------------------------------------------------------------------------- + +else + +DEPENDS := $(OFILES:.o=.d) + +#--------------------------------------------------------------------------------- +# main targets +#--------------------------------------------------------------------------------- +$(OUTPUT).3gx : $(OFILES) + +#--------------------------------------------------------------------------------- +# you need a rule like this for each extension you use as binary data +#--------------------------------------------------------------------------------- +%.bin.o : %.bin +#--------------------------------------------------------------------------------- + @echo $(notdir $<) + @$(bin2o) + +#--------------------------------------------------------------------------------- +%.3gx: %.elf +#--------------------------------------------------------------------------------- + @echo creating $(notdir $@) + @3gxtool -s $(word 1, $^) $(TOPDIR)/$(PLGINFO) $@ + @mv $(OUTPUT).elf AzaharArticSetup.elf + +-include $(DEPENDS) + +#--------------------------------------------------------------------------------- +endif diff --git a/plugin/images/logo.bclim b/plugin/images/logo.bclim new file mode 100644 index 0000000000000000000000000000000000000000..f1be180dd87034422f5b524057538636e4905ef5 GIT binary patch literal 32808 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 E2iuI@^8f$< literal 0 HcmV?d00001 diff --git a/plugin/includes/BCLIM.hpp b/plugin/includes/BCLIM.hpp new file mode 100644 index 0000000..46d8e95 --- /dev/null +++ b/plugin/includes/BCLIM.hpp @@ -0,0 +1,74 @@ +#pragma once +#include "3ds.h" +#include "tuple" +#include "CTRPluginFramework/Vector.hpp" +#include "CTRPluginFramework/Rect.hpp" +#include "CTRPluginFramework/Color.hpp" + +namespace CTRPluginFramework { + class BCLIM { + public: + enum class TextureFormat : u32 { + L8 = 0, + A8 = 1, + LA4 = 2, + LA8 = 3, + HILO8 = 4, + RGB565 = 5, + RGB8 = 6, + RGBA5551 = 7, + RGBA4 = 8, + RGBA8 = 9, + ETC1 = 10, + ETC1A4 = 11, + L4 = 12, + A4 = 13, + }; + struct Header { + u32 magic; + u16 endian; + u16 headerSize; + u32 version; + u32 fileSize; + u32 blockCount; + struct { + u32 magic; + u32 imagHeaderSize; + u16 width; + u16 height; + TextureFormat format; + } imag; + u32 dataLength; + }; + + BCLIM(void* bclimData, u32 bclimSize) : BCLIM(bclimData, (Header*)((u32)bclimData + bclimSize - 0x28)) {} + BCLIM(void* bclimData, Header* bclimHeader) : data(bclimData), header(bclimHeader) {} + + using ColorBlendCallback = Color(*)(const Color &, const Color &); + static std::pair OpaqueBlend() { + return std::make_pair(false, OpaqueBlendFunc); + } + + using RenderBackend = void(*)(void*, bool, Color*, int posX, int posY); + static std::pair RenderInterface() { + return std::make_pair(nullptr, RenderInterfaceBackend); + } + + void Render(const Rect& position, std::pair backend = RenderInterface(), const Rect& crop = Rect(0, 0, INT32_MAX, INT32_MAX), const Rect& limits = Rect(0, 0, 400, 240), std::pair colorBlend = OpaqueBlend()); + + void* data; + private: + Header* header; + static const u8 textureTileOrder[16]; + static const u8 etc1Modifiers[8][2]; + + template + inline T GetDataAt(int offset) { + return *(T*)(((u32)data) + offset); + } + + static void RenderInterfaceBackend(void* usrData, bool isRead, Color* c, int posX, int posY); + + static Color OpaqueBlendFunc(const Color& dst, const Color& src); + }; +} \ No newline at end of file diff --git a/plugin/includes/CTRPluginFramework/CTRPluginFramework.hpp b/plugin/includes/CTRPluginFramework/CTRPluginFramework.hpp new file mode 100644 index 0000000..c92e2ab --- /dev/null +++ b/plugin/includes/CTRPluginFramework/CTRPluginFramework.hpp @@ -0,0 +1,7 @@ +#pragma once + +#include "CTRPluginFramework/System/Mutex.hpp" +#include "CTRPluginFramework/System/Lock.hpp" +#include "CTRPluginFramework/Vector.hpp" +#include "CTRPluginFramework/Rect.hpp" +#include "CTRPluginFramework/Color.hpp" \ No newline at end of file diff --git a/plugin/includes/CTRPluginFramework/Clock.hpp b/plugin/includes/CTRPluginFramework/Clock.hpp new file mode 100644 index 0000000..ac62d8b --- /dev/null +++ b/plugin/includes/CTRPluginFramework/Clock.hpp @@ -0,0 +1,37 @@ +#pragma once +#include "3ds.h" +#include "CTRPluginFramework/Time.hpp" + +namespace CTRPluginFramework +{ + class Clock + { + public: + Clock(void) : _startTime(GetCurrentTime()) {} + constexpr Clock(const Time& time) : _startTime(time) {} + + __always_inline Time GetElapsedTime(void) const { + return (GetCurrentTime() - _startTime); + } + + __always_inline bool HasTimePassed(const Time& time) const { + return (GetElapsedTime() >= time); + } + + __always_inline Time Restart(void) { + const Time now = GetCurrentTime(); + + const Time ret = now - _startTime; + + _startTime = now; + return (ret); + } + private: + Time _startTime; + + static __always_inline Time GetCurrentTime(void) + { + return Ticks(svcGetSystemTick()); + } + }; +} diff --git a/plugin/includes/CTRPluginFramework/Color.hpp b/plugin/includes/CTRPluginFramework/Color.hpp new file mode 100644 index 0000000..5ffd836 --- /dev/null +++ b/plugin/includes/CTRPluginFramework/Color.hpp @@ -0,0 +1,67 @@ +#pragma once +#include "3ds/types.h" +#include +#include + +namespace CTRPluginFramework +{ + class Color + { + public: + + enum class BlendMode + { + Alpha, + Add, + Sub, + Mul, + None + }; + + constexpr Color(void) : a(255), b(0), g(0), r(0) {} + constexpr Color(u32 color) : raw(color) {} + constexpr Color(u8 red, u8 green, u8 blue, u8 alpha = 255) : a(alpha), b(blue), g(green), r(red) {} + + inline u32 ToU32(void) const { return raw; }; + Color &Fade(float fading); + Color Blend(const Color &color, BlendMode mode) const; + + inline bool operator == (const Color &right) const {return raw == right.raw;} + inline bool operator != (const Color &right) const {return raw != right.raw;} + bool operator < (const Color &right) const; + bool operator <= (const Color &right) const; + bool operator > (const Color &right) const; + bool operator >= (const Color &right) const; + Color operator + (const Color &right) const; + Color operator - (const Color &right) const; + Color operator * (const Color &right) const; + Color &operator += (const Color &right); + Color &operator -= (const Color &right); + Color &operator *= (const Color &right); + + operator std::string() const + { + char strColor[5] = { 0 }; + + strColor[0] = 0x1B; + strColor[1] = std::max((u8)1, r); + strColor[2] = std::max((u8)1, g); + strColor[3] = std::max((u8)1, b); + + return strColor; + } + + union + { + u32 raw; + struct // Match raw byte order + { + u8 a; + u8 b; + u8 g; + u8 r; + }; + }; + }; +} + diff --git a/plugin/includes/CTRPluginFramework/Rect.hpp b/plugin/includes/CTRPluginFramework/Rect.hpp new file mode 100644 index 0000000..f9aad0f --- /dev/null +++ b/plugin/includes/CTRPluginFramework/Rect.hpp @@ -0,0 +1,143 @@ +#pragma once +#include "CTRPluginFramework/Vector.hpp" +#include + +namespace CTRPluginFramework +{ + template + class Rect + { + public: + Rect(); + Rect(const Vector& leftTop, const Vector& size); + Rect(const Vector& leftTop, T width, T height); + Rect(T left, T top, const Vector& size); + Rect(T left, T top, T width, T height); + template + explicit Rect(const Rect& rect); + + bool Contains(T x, T y) const; + bool Contains(const Vector& point) const; + bool Intersects(const Rect& rect) const; + bool Intersects(const Rect& rect, Rect& intersect) const; + + Vector leftTop; + Vector size; + }; + + template + Rect::Rect() : leftTop(0, 0), size(0, 0) + { + + } + + template + Rect::Rect(const Vector& leftTopCorner, const Vector& size) + { + leftTop = leftTopCorner; + this->size = size; + } + + template + Rect::Rect(const Vector& leftTopCorner, T width, T height) + { + leftTop = leftTopCorner; + size.x = width; + size.y = height; + } + + template + Rect::Rect(T left, T top, const Vector& size) + { + leftTop.x = left; + leftTop.y = top; + this->size = size; + } + + template + Rect::Rect(T left, T top, T width, T height) + { + leftTop.x = left; + leftTop.y = top; + size.x = width; + size.y = height; + } + + template + template + Rect::Rect(const Rect& rect) + { + leftTop = reinterpret_cast(rect.leftTop); + size = reinterpret_cast(rect.size); + } + + template + bool Rect::Contains(T x, T y) const + { + T minX = std::min(leftTop.x, leftTop.x + size.x); + T maxX = std::max(leftTop.x, leftTop.x + size.x); + T minY = std::min(leftTop.y, leftTop.y + size.y); + T maxY = std::max(leftTop.y, leftTop.y + size.y); + + return (x >= minX && x < maxX + && y >= minY && y < maxY); + } + + template + bool Rect::Contains(const Vector& point) const + { + return (Contains(point.x, point.y)); + } + + template + bool Rect::Intersects(const Rect& rect) const + { + Rect intersect; + return (Intersects(rect, intersect)); + } + + template + bool Rect::Intersects(const Rect &rect, Rect &intersect) const + { + T thisMinX = std::min(leftTop.x, leftTop.x + size.x); + T thisMaxX = std::max(leftTop.x, leftTop.x + size.x); + T thisMinY = std::min(leftTop.y, leftTop.y + size.y); + T thisMaxY = std::max(leftTop.y, leftTop.y + size.y); + T rectMinX = std::min(rect.leftTop.x, rect.leftTop.x + rect.size.x); + T rectMaxX = std::max(rect.leftTop.x, rect.leftTop.x + rect.size.x); + T rectMinY = std::min(rect.leftTop.y, rect.leftTop.y + rect.size.y); + T rectMaxY = std::max(rect.leftTop.y, rect.leftTop.y + rect.size.y); + + T intersectLeftX = std::max(thisMinX, rectMinX); + T intersectLeftY = std::max(thisMinY, rectMinY); + T intersectRightX = std::min(thisMaxX, rectMaxX); + T intersectRightY = std::min(thisMaxY, rectMaxY); + + if (intersectLeftX < intersectRightX && intersectLeftY < intersectRightY) + { + intersect = Rect(intersectLeftX, intersectLeftY, intersectRightX - intersectLeftX, + intersectRightY - intersectLeftY); + return (true); + } + intersect = Rect(0, 0, 0, 0); + return (false); + } + + template + bool operator ==(Rect &left, Rect &right) + { + return (left.leftTop == right.leftTop + && left.size == right.size); + } + + template + bool operator !=(Rect &left, Rect &right) + { + return (left.leftTop != right.leftTop + && left.size != right.size); + } + + typedef Rect UIntRect; + typedef Rect IntRect; + typedef Rect FloatRect; +} diff --git a/plugin/includes/CTRPluginFramework/System/Lock.hpp b/plugin/includes/CTRPluginFramework/System/Lock.hpp new file mode 100644 index 0000000..6107e8e --- /dev/null +++ b/plugin/includes/CTRPluginFramework/System/Lock.hpp @@ -0,0 +1,54 @@ +#ifndef CTRPLUGINFRAMEWORK_SYSTEM_LOCK_HPP +#define CTRPLUGINFRAMEWORK_SYSTEM_LOCK_HPP + +#include "3ds.h" + +namespace CTRPluginFramework +{ + class Mutex; + class Lock + { + public: + inline explicit Lock(LightLock &llock) : + _type{LIGHTLOCK}, _llock{&llock} + { + LightLock_Lock(_llock); + } + + inline explicit Lock(RecursiveLock &rlock) : + _type{RECLOCK}, _rlock{&rlock} + { + RecursiveLock_Lock(_rlock); + } + + inline explicit Lock(Mutex &mutex) : + _type{MUTEX}, _mutex{&mutex} + { + mutex.Lock(); + } + + inline ~Lock(void) + { + if (_type == LIGHTLOCK) + LightLock_Unlock(_llock); + else if (_type == RECLOCK) + RecursiveLock_Unlock(_rlock); + else if (_type == MUTEX) + _mutex->Unlock(); + } + + private: + static const constexpr u32 LIGHTLOCK = 1; + static const constexpr u32 RECLOCK = 2; + static const constexpr u32 MUTEX = 3; + const u32 _type; + union + { + LightLock *_llock; + RecursiveLock *_rlock; + Mutex *_mutex; + }; + }; +} + +#endif diff --git a/plugin/includes/CTRPluginFramework/System/Mutex.hpp b/plugin/includes/CTRPluginFramework/System/Mutex.hpp new file mode 100644 index 0000000..ca1b9b8 --- /dev/null +++ b/plugin/includes/CTRPluginFramework/System/Mutex.hpp @@ -0,0 +1,41 @@ +#ifndef CTRPLUGINFRAMEWORK_SYSTEM_MUTEX_HPP +#define CTRPLUGINFRAMEWORK_SYSTEM_MUTEX_HPP + +#include "3ds.h" + +namespace CTRPluginFramework +{ + class Mutex + { + public: + inline Mutex(void) { + RecursiveLock_Init(&_lock); + } + inline ~Mutex(void) { + // I suppose that we can "force" unlock the mutex + if (_lock.counter > 0) + { + _lock.counter = 1; + RecursiveLock_Unlock(&_lock); + } + } + + inline void Lock(void) { + RecursiveLock_Lock(&_lock); + } + + // Return true on failure + inline bool TryLock(void) { + return RecursiveLock_TryLock(&_lock) != 0; + } + + inline void Unlock(void) { + RecursiveLock_Unlock(&_lock); + } + + private: + RecursiveLock _lock; + }; +} + +#endif diff --git a/plugin/includes/CTRPluginFramework/Time.hpp b/plugin/includes/CTRPluginFramework/Time.hpp new file mode 100644 index 0000000..5cd6b7c --- /dev/null +++ b/plugin/includes/CTRPluginFramework/Time.hpp @@ -0,0 +1,205 @@ +#pragma once + +#include "3ds/types.h" + +namespace CTRPluginFramework +{ + class Time + { + public : + + constexpr Time(void) : _ticks(0) {} + + + float AsSeconds(void) const; + + int AsMilliseconds(void) const; + + s64 AsMicroseconds(void) const; + + inline s64 AsTicks(void) const { return _ticks; } + + static const Time Zero; ///< Predefined "zero" time value + + static constexpr u32 TicksPerSecond = 268111856U; + + private : + + friend constexpr Time Seconds(float amount); + friend constexpr Time Milliseconds(int amount); + friend constexpr Time Microseconds(s64 amount); + friend constexpr Time Ticks(s64 amount); + + constexpr Time(s64 ticks) : _ticks(ticks) {} + + private : + + + s64 _ticks; + }; + + constexpr Time Seconds(float amount) + { + return (Time(static_cast(amount * Time::TicksPerSecond))); + } + + + constexpr Time Milliseconds(int amount) + { + return (Time(static_cast(amount * (Time::TicksPerSecond / 1000.f)))); + } + + + constexpr Time Microseconds(s64 amount) + { + return (Time(static_cast(amount * (Time::TicksPerSecond / 1000000.f)))); + } + + constexpr Time Ticks(s64 amount) + { + return (Time(amount)); + } + + inline bool operator ==(const Time& left, const Time& right) + { + return (left.AsTicks() == right.AsTicks()); + } + + + inline bool operator !=(const Time& left, const Time& right) + { + return (left.AsTicks() != right.AsTicks()); + } + + + inline bool operator <(const Time& left, const Time& right) + { + return (left.AsTicks() < right.AsTicks()); + } + + + inline bool operator >(const Time& left, const Time& right) + { + return (left.AsTicks() > right.AsTicks()); + } + + + inline bool operator <=(const Time& left, const Time& right) + { + return (left.AsTicks() <= right.AsTicks()); + } + + inline bool operator >=(const Time& left, const Time& right) + { + return (left.AsTicks() >= right.AsTicks()); + } + + inline Time operator -(const Time& right) + { + return (Ticks(-right.AsTicks())); + } + + + inline Time operator +(const Time& left, const Time& right) + { + return (Ticks(left.AsTicks() + right.AsTicks())); + } + + + inline Time& operator +=(Time& left, const Time& right) + { + return (left = left + right); + } + + + inline Time operator -(const Time& left, const Time& right) + { + return (Ticks(left.AsTicks() - right.AsTicks())); + } + + + inline Time& operator -=(Time& left, const Time& right) + { + return left = left - right; + } + + + inline Time operator *(const Time& left, float right) + { + return (Seconds(left.AsSeconds() * right)); + } + + + inline Time operator *(const Time& left, s64 right) + { + return (Microseconds(left.AsMicroseconds() * right)); + } + + + inline Time operator *(float left, const Time& right) + { + return (right * left); + } + + + inline Time operator *(s64 left, const Time& right) + { + return (right * left); + } + + + inline Time& operator *=(Time& left, float right) + { + return (left = left * right); + } + + + inline Time& operator *=(Time& left, s64 right) + { + return (left = left * right); + } + + + inline Time operator /(const Time& left, float right) + { + return Seconds(left.AsSeconds() / right); + } + + + inline Time operator /(const Time& left, s64 right) + { + return (Microseconds(left.AsMicroseconds() / right)); + } + + + inline Time& operator /=(Time& left, float right) + { + return (left = left / right); + } + + + inline Time& operator /=(Time& left, s64 right) + { + return (left = left / right); + } + + + inline float operator /(const Time& left, const Time& right) + { + return (left.AsSeconds() / right.AsSeconds()); + } + + + inline Time operator %(const Time& left, const Time& right) + { + return (Ticks(left.AsTicks() % right.AsTicks())); + } + + + inline Time& operator %=(Time& left, const Time& right) + { + return (left = left % right); + } + +} + diff --git a/plugin/includes/CTRPluginFramework/Vector.hpp b/plugin/includes/CTRPluginFramework/Vector.hpp new file mode 100644 index 0000000..c786d20 --- /dev/null +++ b/plugin/includes/CTRPluginFramework/Vector.hpp @@ -0,0 +1,124 @@ +#pragma once +#include "3ds/types.h" + +namespace CTRPluginFramework +{ + template + class Vector + { + public: + Vector(); + Vector(T x, T y); + template + explicit Vector(const Vector &vector); + + T x; + T y; + }; + + template + Vector::Vector() : x(0), y(0) + { + + } + + template + Vector::Vector(T x, T y) : x(x), y(y) + { + + } + + template + template + Vector::Vector(const Vector &vector) : x(static_cast(vector.x)), y(static_cast(vector.y)) + { + + } + + template + Vector operator - (const Vector &vector) + { + return (Vector(-vector.x, -vector.y)); + } + + template + Vector operator - (const Vector &left, const Vector &right) + { + return (Vector(left.x - right.x, left.y - right.y)); + } + + template + Vector &operator -= (const Vector &left, const Vector &right) + { + left.x -= right.x; + left.y -= right.y; + return (left); + } + + template + Vector operator + (const Vector &left, const Vector &right) + { + return (Vector(left.x + right.x, left.y + right.y)); + } + + template + Vector &operator += (const Vector &left, const Vector &right) + { + left.x += right.x; + left.y += right.y; + return (left); + } + + template + Vector operator * (const Vector &left, T right) + { + return (Vector(left.x * right, left.y * right)); + } + + template + Vector operator * (const T left, const Vector &right) + { + return (Vector(right.x * left, right.y * left)); + } + + template + Vector &operator *= (Vector &left, const T right) + { + left.x *= right; + left.y *= right; + return (left); + } + + template + Vector operator / (const Vector &left, const T right) + { + return (Vector(left.x / right, left.y / right)); + } + + template + Vector &operator /= (Vector &left, const T right) + { + left.x /= right; + left.y /= right; + return (left); + } + + template + bool operator <= (const Vector &left, const Vector &right) + { + return (left.x <= right.x + && left.y <= right.y); + } + + template + bool operator >= (const Vector &left, const Vector &right) + { + return (left.x >= right.x + && left.y >= right.y); + } + + typedef Vector UIntVector; + typedef Vector IntVector; + typedef Vector FloatVector; + typedef Vector shortVector; +} diff --git a/plugin/includes/Intellisense.hpp b/plugin/includes/Intellisense.hpp new file mode 100644 index 0000000..6b3cc9a --- /dev/null +++ b/plugin/includes/Intellisense.hpp @@ -0,0 +1,6 @@ +// Only used by Visual Studio Intellisense + +#define VERSION_MAJOR 0 +#define VERSION_MINOR 0 +#define VERSION_REVISION 1 +#define SERVER_PORT 5543 diff --git a/plugin/includes/Main.hpp b/plugin/includes/Main.hpp new file mode 100644 index 0000000..a89026c --- /dev/null +++ b/plugin/includes/Main.hpp @@ -0,0 +1,5 @@ +#pragma once +#include "3ds.h" +#include "Logger.hpp" + +extern Logger logger; diff --git a/plugin/includes/csvc.h b/plugin/includes/csvc.h new file mode 100644 index 0000000..543a2a6 --- /dev/null +++ b/plugin/includes/csvc.h @@ -0,0 +1,154 @@ +/* This paricular file is licensed under the following terms: */ + +/* +* This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable +* for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it +* and redistribute it freely, subject to the following restrictions: +* +* The origin of this software must not be misrepresented; you must not claim that you wrote the original software. +* If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +* +* Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +* This notice may not be removed or altered from any source distribution. +*/ + +#pragma once + +#include <3ds/types.h> + +/// Operations for svcControlService +typedef enum ServiceOp +{ + SERVICEOP_STEAL_CLIENT_SESSION = 0, ///< Steal a client session given a service or global port name + SERVICEOP_GET_NAME, ///< Get the name of a service or global port given a client or session handle +} ServiceOp; + +/** + * @brief Executes a function in supervisor mode, using the supervisor-mode stack. + * @param func Function to execute. + * @param ... Function parameters, up to 3 registers. +*/ +Result svcCustomBackdoor(void *func, ...); + +///@name I/O +///@{ +/** + * @brief Gives the physical address corresponding to a virtual address. + * @param VA Virtual address. + * @param writeCheck whether to check if the VA is writable in supervisor mode + * @return The corresponding physical address, or NULL. +*/ +u32 svcConvertVAToPA(const void *VA, bool writeCheck); + +/** + * @brief Flushes a range of the data cache (L2C included). + * @param addr Start address. + * @param len Length of the range. +*/ +void svcFlushDataCacheRange(void *addr, u32 len); + +/** + * @brief Flushes the data cache entirely (L2C included). +*/ +void svcFlushEntireDataCache(void); + +/** + * @brief Invalidates a range of the instruction cache. + * @param addr Start address. + * @param len Length of the range. +*/ +void svcInvalidateInstructionCacheRange(void *addr, u32 len); + +/** + * @brief Invalidates the data cache entirely. +*/ +void svcInvalidateEntireInstructionCache(void); +///@} + +///@name Memory management +///@{ +/** + * @brief Maps a block of process memory. + * @param dstProcessHandle Handle of the process to map the memory in (destination) + * @param destAddress Address of the mapped block in the current process. + * @param srcProcessHandle Handle of the process to map the memory from (source) + * @param srcAddress Address of the mapped block in the source process. + * @param size Size of the block of the memory to map (truncated to a multiple of 0x1000 bytes). +*/ +Result svcMapProcessMemoryEx(Handle dstProcessHandle, u32 destAddress, Handle srcProcessHandle, u32 vaSrc, u32 size); + +/** + * @brief Unmaps a block of process memory. + * @param process Handle of the process to unmap the memory from + * @param destAddress Address of the block of memory to unmap + * @param size Size of the block of memory to unmap (truncated to a multiple of 0x1000 bytes). + * This function should only be used to unmap memory mapped with svcMapProcessMemoryEx + */ +Result svcUnmapProcessMemoryEx(Handle process, u32 destAddress, u32 size); + +/** + * @brief Controls memory mapping, with the choice to use region attributes or not. + * @param[out] addr_out The virtual address resulting from the operation. Usually the same as addr0. + * @param addr0 The virtual address to be used for the operation. + * @param addr1 The virtual address to be (un)mirrored by @p addr0 when using @ref MEMOP_MAP or @ref MEMOP_UNMAP. + * It has to be pointing to a RW memory. + * Use NULL if the operation is @ref MEMOP_FREE or @ref MEMOP_ALLOC. + * @param size The requested size for @ref MEMOP_ALLOC and @ref MEMOP_ALLOC_LINEAR. + * @param op Operation flags. See @ref MemOp. + * @param perm A combination of @ref MEMPERM_READ and @ref MEMPERM_WRITE. Using MEMPERM_EXECUTE will return an error. + * Value 0 is used when unmapping memory. + * @param isLoader Whether to use the region attributes + * If a memory is mapped for two or more addresses, you have to use MEMOP_UNMAP before being able to MEMOP_FREE it. + * MEMOP_MAP will fail if @p addr1 was already mapped to another address. + * + * @sa svcControlMemory + */ +Result svcControlMemoryEx(u32* addr_out, u32 addr0, u32 addr1, u32 size, MemOp op, MemPerm perm, bool isLoader); +///@} + +///@name System +///@{ +/** + * @brief Performs actions related to services or global handles. + * @param op The operation to perform, see @ref ServiceOp. + * + * Examples: + * svcControlService(SERVICEOP_GET_NAME, (char [12])outName, (Handle)clientOrSessionHandle); + * svcControlService(SERVICEOP_STEAL_CLIENT_SESSION, (Handle *)&outHandle, (const char *)name); + */ +Result svcControlService(ServiceOp op, ...); + +/** + * @brief Copy a handle from a process to another one. + * @param[out] out The output handle. + * @param outProcess Handle of the process of the output handle. + * @param in The input handle. Pseudo-handles are not accepted. + * @param inProcess Handle of the process of the input handle. +*/ +Result svcCopyHandle(Handle *out, Handle outProcess, Handle in, Handle inProcess); + +/** + * @brief Get the address and class name of the underlying kernel object corresponding to a handle. + * @param[out] outKAddr The output kernel address. + * @param[out] outName Output class name. The buffer should be large enough to contain it. + * @param in The input handle. +*/ +Result svcTranslateHandle(u32 *outKAddr, char *outClassName, Handle in); + +/// Operations for svcControlProcess +typedef enum ProcessOp +{ + PROCESSOP_GET_ALL_HANDLES, ///< List all handles of the process, varg3 can be either 0 to fetch all handles, or token of the type to fetch + ///< svcControlProcess(handle, PROCESSOP_GET_ALL_HANDLES, (u32)&outBuf, 0) + PROCESSOP_SET_MMU_TO_RWX, ///< Set the whole memory of the process with rwx access + ///< svcControlProcess(handle, PROCESSOP_SET_MMU_TO_RWX, 0, 0) + PROCESSOP_GET_ON_MEMORY_CHANGE_EVENT, + PROCESSOP_GET_ON_EXIT_EVENT, + PROCESSOP_GET_PA_FROM_VA, ///< Get the physical address of the va within the process + ///< svcControlProcess(handle, PROCESSOP_GET_PA_FROM_VA, (u32)&outPa, va) +} ProcessOp; + +Result svcControlProcess(Handle process, ProcessOp op, u32 varg2, u32 varg3); +///@} diff --git a/plugin/includes/logo.h b/plugin/includes/logo.h new file mode 100644 index 0000000..9ffb462 --- /dev/null +++ b/plugin/includes/logo.h @@ -0,0 +1,9 @@ +/* Generated by bin2c, do not edit manually */ +#ifndef ____includes_logo_h_included +#define ____includes_logo_h_included + +/* Contents of file .\data\logo.bin */ +extern const long int __data_logo_bin_size; +extern const unsigned char __data_logo_bin[32808]; + +#endif /* ____includes_logo_h_included */ diff --git a/plugin/includes/nim_extheader.h b/plugin/includes/nim_extheader.h new file mode 100644 index 0000000..52fb100 --- /dev/null +++ b/plugin/includes/nim_extheader.h @@ -0,0 +1,134 @@ +/* Generated by bin2c, do not edit manually */ + +/* Contents of file extheader.bin */ +const long int nim_extheader_bin_size = 2048; +const unsigned char nim_extheader_bin[2048] = { + 0x6E, 0x69, 0x6D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0E, 0x00, + 0x00, 0x00, 0x10, 0x00, 0x51, 0x00, 0x00, 0x00, 0x7C, 0x01, 0x05, 0x00, 0x00, 0x10, 0x00, 0x00, + 0x00, 0x10, 0x15, 0x00, 0x05, 0x00, 0x00, 0x00, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x60, 0x15, 0x00, 0x01, 0x00, 0x00, 0x00, 0xA8, 0x09, 0x00, 0x00, 0xC8, 0x02, 0x13, 0x00, + 0x02, 0x24, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x15, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, + 0x02, 0x17, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x29, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, + 0x02, 0x2F, 0x00, 0x00, 0x30, 0x01, 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, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x2C, 0x00, 0x00, 0x30, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x2C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x3D, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x61, 0x6D, 0x3A, 0x6E, 0x65, 0x74, 0x00, 0x00, + 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, + 0x63, 0x66, 0x67, 0x3A, 0x73, 0x00, 0x00, 0x00, 0x70, 0x74, 0x6D, 0x3A, 0x73, 0x00, 0x00, 0x00, + 0x70, 0x74, 0x6D, 0x3A, 0x67, 0x65, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, + 0x4E, 0x9F, 0xFA, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x80, 0xF2, 0xFD, 0x00, 0x00, 0xF3, + 0x80, 0x03, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, + 0x02, 0x20, 0xE3, 0x4B, 0xE4, 0x26, 0xA3, 0x5F, 0x83, 0x17, 0x88, 0xB5, 0x0F, 0xDA, 0x7A, 0x77, + 0xDB, 0xC7, 0x03, 0x50, 0xB0, 0xEC, 0xE5, 0x9B, 0x47, 0x0B, 0x2F, 0x21, 0x97, 0xF7, 0x81, 0xF5, + 0x57, 0xAB, 0xBF, 0x1D, 0xA0, 0x96, 0x72, 0x2A, 0x6F, 0x6F, 0x06, 0x51, 0xC3, 0x86, 0x4C, 0x31, + 0x34, 0x10, 0x81, 0xDC, 0x61, 0x10, 0x73, 0x57, 0xEF, 0xCC, 0x49, 0x09, 0x46, 0x84, 0x9C, 0xEA, + 0xFA, 0xDB, 0xC6, 0xF7, 0x8F, 0xCE, 0x40, 0x9F, 0xD0, 0x38, 0x90, 0xE4, 0x2D, 0xA1, 0xAC, 0x51, + 0xF0, 0x9D, 0xF8, 0xBC, 0xC1, 0xDC, 0xD2, 0xCB, 0xDE, 0x60, 0x25, 0x3A, 0xB5, 0x12, 0xC5, 0x21, + 0x1E, 0x41, 0x2C, 0x56, 0x8F, 0xB0, 0x8A, 0x8B, 0x0E, 0xF5, 0x40, 0x73, 0xD1, 0x17, 0x3F, 0x2B, + 0x8E, 0x34, 0x3C, 0x55, 0xC2, 0xC4, 0x74, 0x74, 0x84, 0x2E, 0xDC, 0xC6, 0xB5, 0x95, 0x71, 0x7C, + 0xBA, 0xF8, 0x3B, 0xC8, 0x31, 0x4A, 0x85, 0x7A, 0xD1, 0x76, 0xAD, 0x41, 0xBD, 0xAA, 0x9A, 0xE8, + 0x81, 0x0A, 0x64, 0x99, 0x86, 0x41, 0x3A, 0xB2, 0xEB, 0x2F, 0xB7, 0x52, 0x3F, 0xDA, 0x2C, 0x60, + 0x70, 0x45, 0xAB, 0x0F, 0x2C, 0x31, 0xD3, 0x35, 0x6E, 0x02, 0x40, 0x3C, 0x63, 0x58, 0x8F, 0x28, + 0x5F, 0xD2, 0x7C, 0xDF, 0x42, 0xAA, 0x5E, 0x5D, 0x4D, 0x50, 0x61, 0xA9, 0x2A, 0x81, 0x49, 0xA7, + 0xA3, 0x76, 0xE6, 0xA4, 0x33, 0x08, 0xAD, 0x93, 0xF5, 0x18, 0x54, 0x50, 0xFC, 0xAE, 0x66, 0x44, + 0x92, 0x23, 0xB5, 0xF6, 0x2F, 0xAE, 0x57, 0xCB, 0x42, 0x92, 0x56, 0xAC, 0xE4, 0xBE, 0x83, 0xDB, + 0x05, 0x5E, 0x18, 0x2E, 0x1D, 0xB4, 0x35, 0x8D, 0xE5, 0x3C, 0xDC, 0xB3, 0x90, 0x9D, 0x6C, 0xDB, + 0x0F, 0xC0, 0xC3, 0xD8, 0x4F, 0xA5, 0xF3, 0x79, 0x8A, 0xC4, 0xD9, 0x13, 0x07, 0x06, 0x9F, 0xC1, + 0xA6, 0x92, 0x3F, 0xDE, 0x62, 0x6C, 0x2B, 0xBC, 0x70, 0x94, 0x81, 0x79, 0x80, 0xF6, 0x6E, 0xF9, + 0xBD, 0x6D, 0xC0, 0xDD, 0xA8, 0x7D, 0x54, 0xE3, 0xC8, 0x0D, 0x0E, 0xDA, 0x5F, 0x4C, 0x23, 0x75, + 0x11, 0xE2, 0x0F, 0x16, 0x0A, 0x48, 0x5D, 0xE9, 0xD3, 0x5F, 0x7E, 0x8B, 0x55, 0x9B, 0xC1, 0xC9, + 0xA4, 0xED, 0xA6, 0x1A, 0x3A, 0xFD, 0xA7, 0x82, 0x3B, 0x1C, 0xE3, 0x73, 0xE3, 0xBA, 0xC7, 0x86, + 0x05, 0x93, 0xE4, 0x0A, 0xC1, 0x6C, 0x3E, 0xC8, 0x87, 0x11, 0x5F, 0x98, 0xCC, 0x76, 0x23, 0xA3, + 0xA5, 0x79, 0x95, 0x0A, 0xDD, 0x7D, 0x27, 0x0F, 0x26, 0x85, 0x0A, 0xE9, 0x4F, 0x2D, 0x23, 0x44, + 0xF7, 0xA5, 0xE8, 0x7F, 0x17, 0x7F, 0x65, 0x5F, 0x4D, 0xCD, 0x6D, 0xF2, 0xDB, 0x64, 0xF4, 0x30, + 0xD1, 0x57, 0x2B, 0x92, 0x34, 0xDA, 0x60, 0xB5, 0xF7, 0x26, 0x4A, 0xC3, 0x66, 0xC0, 0x27, 0x35, + 0xD5, 0xF2, 0xB5, 0xB0, 0xB0, 0xE6, 0xB3, 0xC9, 0x92, 0xEB, 0x8F, 0x40, 0x38, 0x9C, 0xE4, 0x30, + 0x9C, 0x13, 0xF9, 0x2F, 0x5B, 0x90, 0x67, 0x30, 0xE9, 0x44, 0xD9, 0x7F, 0x8C, 0x09, 0x34, 0xEE, + 0x89, 0x67, 0xD6, 0x00, 0xA1, 0x54, 0xB1, 0xD5, 0x10, 0x72, 0xD5, 0xDA, 0x15, 0x1E, 0x50, 0xB4, + 0x25, 0xD7, 0x82, 0xD3, 0xAA, 0x0B, 0xD0, 0x65, 0x77, 0x8D, 0x5D, 0x07, 0xFF, 0x9B, 0x8E, 0xF0, + 0x8C, 0x37, 0x23, 0x13, 0x6C, 0xFD, 0xF8, 0xE6, 0xB6, 0x8E, 0xB2, 0x89, 0xAB, 0x44, 0x69, 0x30, + 0x96, 0x50, 0x8B, 0x88, 0xCB, 0xF4, 0x47, 0x60, 0x7D, 0xC5, 0xA7, 0xAB, 0x3B, 0x45, 0x7E, 0xDF, + 0x8C, 0x6D, 0x0C, 0x2B, 0x3F, 0x40, 0x3A, 0x55, 0xB2, 0xF7, 0xDF, 0x26, 0x21, 0xBE, 0xC5, 0x5F, + 0x82, 0xCF, 0xE2, 0x51, 0x74, 0x43, 0xEC, 0x57, 0xA1, 0x04, 0x8C, 0x19, 0x4F, 0x86, 0xB9, 0x49, + 0xFF, 0x2C, 0x00, 0xF0, 0x30, 0x01, 0x04, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x01, 0x00, 0xFF, 0xFF, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x61, 0x6D, 0x3A, 0x6E, 0x65, 0x74, 0x00, 0x00, + 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, + 0x63, 0x66, 0x67, 0x3A, 0x73, 0x00, 0x00, 0x00, 0x70, 0x74, 0x6D, 0x3A, 0x73, 0x00, 0x00, 0x00, + 0x70, 0x74, 0x6D, 0x3A, 0x67, 0x65, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, + 0x4E, 0x9F, 0xFA, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x80, 0xF2, 0xFD, 0x00, 0x00, 0xF3, + 0x80, 0x03, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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 +}; diff --git a/plugin/includes/plgldr.h b/plugin/includes/plgldr.h new file mode 100644 index 0000000..1b9d854 --- /dev/null +++ b/plugin/includes/plgldr.h @@ -0,0 +1,79 @@ +#pragma once +#ifdef __cplusplus +extern "C" { +#endif + +#include <3ds/types.h> +#define MAX_BUFFER (50) +#define MAX_ITEMS_COUNT (64) +#define HeaderMagic (0x24584733) /* "3GX$" */ + +typedef struct +{ + bool noFlash; + u8 pluginMemoryStrategy; + u8 persistent; + u32 lowTitleId; + char path[256]; + u32 config[32]; +} PluginLoadParameters; + +typedef struct +{ + u32 nbItems; + u8 states[MAX_ITEMS_COUNT]; + char title[MAX_BUFFER]; + char items[MAX_ITEMS_COUNT][MAX_BUFFER]; + char hints[MAX_ITEMS_COUNT][MAX_BUFFER]; +} PluginMenu; + +typedef enum +{ + PLG_WAIT = -1, + PLG_OK = 0, + PLG_SLEEP_ENTRY = 1, + PLG_SLEEP_EXIT = 2, + PLG_ABOUT_TO_SWAP = 3, + PLG_ABOUT_TO_EXIT = 4, + PLG_HOME_ENTER = 5, + PLG_HOME_EXIT = 6, +} PLG_Event; + +typedef struct ///< Defined by Luma3DS plugin loader +{ + u32 magic; + u32 version; + u32 heapVA; + u32 heapSize; + u32 exeSize; // Include sizeof(PluginHeader) + .text + .rodata + .data + .bss (0x1000 aligned too) + u32 isDefaultPlugin; + s32* plgldrEvent; ///< Used for synchronization + s32* plgldrReply; ///< Used for synchronization + u8 notifyHomeEvent; + u8 padding[3]; + u32 reserved[23]; + u32 config[32]; +} PluginHeader; + + +typedef void (*OnPlgLdrEventCb_t)(s32 eventType); + +Result plgLdrInit(void); +void plgLdrExit(void); +Result PLGLDR__IsPluginLoaderEnabled(bool *isEnabled); +Result PLGLDR__SetPluginLoaderState(bool enabled); +Result PLGLDR__SetPluginLoadParameters(PluginLoadParameters *parameters); +Result PLGLDR__DisplayMenu(PluginMenu *menu); +Result PLGLDR__DisplayMessage(const char *title, const char *body); +Result PLGLDR__DisplayErrMessage(const char *title, const char *body, u32 error); +Result PLGLDR__GetVersion(u32 *version); +Result PLGLDR__GetPluginPath(char *path); +Result PLGLDR__SetRosalinaMenuBlock(bool shouldBlock); +Result PLGLDR__SetSwapSettings(const char* swapPath, void* encFunc, void* decFunc, void* args); +void PLGLDR__SetEventCallback(OnPlgLdrEventCb_t cb); +void PLGLDR__Status(void); +Result PLGLDR__ClearPluginLoadParameters(); + +#ifdef __cplusplus +} +#endif diff --git a/plugin/sendfile.py b/plugin/sendfile.py new file mode 100644 index 0000000..a9b47ad --- /dev/null +++ b/plugin/sendfile.py @@ -0,0 +1,57 @@ +#!/usr/bin/env Python + +import sys +import ftplib +import datetime +from ftplib import FTP + +# Usage: +# sendfile.py "filename" "ftppath" "host" "ip" + +def printf(string): + print(datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S') + " : " + string); + +if __name__ == '__main__': + print(""); + printf("FTP File Sender\n") + try: + filename = sys.argv[1] + path = sys.argv[2] + host = sys.argv[3] + port = sys.argv[4] + destfile = sys.argv[5] + + ftp = FTP() + printf("Connecting to " + host + ":" + port); + ftp.connect(host, int(port), timeout=3); + printf("Connected"); + + printf("Opening " + filename); + file = open(sys.argv[1], "rb"); + printf("Success"); + + except IOError as e: + printf("/!\ An error occured. /!\ "); + + printf("Moving to: ftp:/" + path); + try: + ftp.cwd(path); + except IOError: + try: + ftp.mkd(path); + ftp.cwd(path); + except Exception: + pass + + try: + printf("Sending file"); + ftp.storbinary('STOR '+ destfile, file); + printf("Done") + + file.close(); + + ftp.quit(); + printf("Disconnected"); + + except Exception: + printf("/!\ An error occured. /!\ "); diff --git a/plugin/sources/3gx_crt0.s b/plugin/sources/3gx_crt0.s new file mode 100644 index 0000000..4df2d6c --- /dev/null +++ b/plugin/sources/3gx_crt0.s @@ -0,0 +1,86 @@ +/*-------------------------------------------------------------------------------- + This Source Code Form is subject to the terms of the Mozilla Public License, + v. 2.0. If a copy of the MPL was not distributed with this file, You can + obtain one at https://mozilla.org/MPL/2.0/. +--------------------------------------------------------------------------------*/ + +@--------------------------------------------------------------------------------- +@ 3DS processor selection +@--------------------------------------------------------------------------------- + .cpu mpcore +@--------------------------------------------------------------------------------- + +@--------------------------------------------------------------------------------- + .section ".crt0","ax" + .global _start, __service_ptr, __apt_appid, __ctru_heap_size, __ctru_linear_heap_size, __system_arglist, __system_runflags +@--------------------------------------------------------------------------------- + .align 2 + .arm +@--------------------------------------------------------------------------------- +_start: +@--------------------------------------------------------------------------------- + b startup + .ascii "_prm" +__service_ptr: + .word 0 @ Pointer to service handle override list -- if non-NULL it is assumed that we have been launched from a homebrew launcher +__apt_appid: + .word 0x300 @ Program APPID +__ctru_heap_size: + .word 24*1024*1024 @ Default heap size (24 MiB) +__ctru_linear_heap_size: + .word 24*1024*1024 @ Default linear heap size (24 MiB) +__system_arglist: + .word 0 @ Pointer to argument list (argc (u32) followed by that many NULL terminated strings) +__system_runflags: + .word 0 @ Flags to signal runtime restrictions to ctrulib +startup: + @ Restore plugin loader state, including the pushed stack registers + add sp, sp, #4 + ldmfd sp!, {r0} + msr cpsr, r0 + ldmfd sp!, {r0-r12} + mov lr, #0 + + @ Save return address + mov r4, lr + + @ Clear the BSS section + ldr r0, =__bss_start__ + ldr r1, =__bss_end__ + sub r1, r1, r0 + bl ClearMem + + @ System initialization + mov r0, r4 + bl initSystem + + @ Set up argc/argv arguments for main() + ldr r0, =__system_argc + ldr r1, =__system_argv + ldr r0, [r0] + ldr r1, [r1] + + @ Jump to user code + ldr r3, =main + ldr lr, =exit + bx r3 + +@--------------------------------------------------------------------------------- +@ Clear memory to 0x00 if length != 0 +@ r0 = Start Address +@ r1 = Length +@--------------------------------------------------------------------------------- +ClearMem: +@--------------------------------------------------------------------------------- + mov r2, #3 @ Round down to nearest word boundary + add r1, r1, r2 @ Shouldn't be needed + bics r1, r1, r2 @ Clear 2 LSB (and set Z) + bxeq lr @ Quit if copy size is 0 + + mov r2, #0 +ClrLoop: + stmia r0!, {r2} + subs r1, r1, #4 + bne ClrLoop + + bx lr \ No newline at end of file diff --git a/plugin/sources/ArticBaseFunctions.cpp b/plugin/sources/ArticBaseFunctions.cpp new file mode 100644 index 0000000..ef91959 --- /dev/null +++ b/plugin/sources/ArticBaseFunctions.cpp @@ -0,0 +1,906 @@ +#include +#include +#include +#include +#include + +#include "ArticFunctions.hpp" +#include "Main.hpp" +#include "CTRPluginFramework/CTRPluginFramework.hpp" +#include "CTRPluginFramework/Clock.hpp" +#include "nim_extheader.h" + +extern "C" { +#include "csvc.h" +} + +extern bool isControllerMode; +constexpr u32 INITIAL_SETUP_APP_VERSION = 0; + +enum class HandleType { + FILE, + DIR, + ARCHIVE +}; + +namespace ArticBaseFunctions { + + ExHeader_Info lastAppExheader; + std::map openHandles; + CTRPluginFramework::Mutex amMutex; + CTRPluginFramework::Mutex cfgMutex; + + void Process_GetTitleID(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + ArticBaseCommon::Buffer* tid_buffer = mi.ReserveResultBuffer(0, sizeof(u64)); + if (!tid_buffer) { + return; + } + s64 out; + svcGetProcessInfo(&out, CUR_PROCESS_HANDLE, 0x10001); + + memcpy(tid_buffer->data, &out, sizeof(s64)); + + mi.FinishGood(0); + } + + void Process_GetProductInfo(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + ArticBaseCommon::Buffer* prod_code_buffer = mi.ReserveResultBuffer(0, sizeof(FS_ProductInfo)); + if (!prod_code_buffer) { + return; + } + + u32 pid; + Result res = svcGetProcessId(&pid, CUR_PROCESS_HANDLE); + if (R_SUCCEEDED(res)) res = FSUSER_GetProductInfo((FS_ProductInfo*)prod_code_buffer->data, pid); + if (R_FAILED(res)) { + logger.Error("Process_GetProductInfo: 0x%08X", res); + mi.FinishInternalError(); + return; + } + + mi.FinishGood(0); + } + + void Process_GetExheader(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + ArticBaseCommon::Buffer* exheader_buf = mi.ReserveResultBuffer(0, sizeof(lastAppExheader)); + if (!exheader_buf) { + return; + } + memcpy(exheader_buf->data, &lastAppExheader, exheader_buf->bufferSize); + + mi.FinishGood(0); + } + + void Process_ReadCode(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s32 offset, size; + + if (good) good = mi.GetParameterS32(offset); + if (good) good = mi.GetParameterS32(size); + if (good) good = mi.FinishInputParameters(); + if (!good) return; + + s64 out; + if (R_FAILED(svcGetProcessInfo(&out, CUR_PROCESS_HANDLE, 0x10005))) { + mi.FinishInternalError(); + return; + } + u8* start_addr = reinterpret_cast(out); + + ArticBaseCommon::Buffer* code_buf = mi.ReserveResultBuffer(0, size); + if (!code_buf) { + return; + } + memcpy(code_buf->data, start_addr + offset, size); + + mi.FinishGood(0); + } + + static void _Process_ReadExefs(ArticProtocolServer::MethodInterface& mi, const char* section) { + bool good = true; + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + // Set up FS_Path structures + u8 path[0xC] = {0}; + u32* type = (u32*)path; + char* name = (char*)(path + sizeof(u32)); + + *type = 0x2; // ExeFS + strcpy(name, section); // Icon + + FS_Path archPath = { PATH_EMPTY, 1, "" }; + FS_Path filePath = { PATH_BINARY, sizeof(path), path }; + + // Open the RomFS file and mount it + Handle fd = 0; + Result rc = FSUSER_OpenFileDirectly(&fd, ARCHIVE_ROMFS, archPath, filePath, FS_OPEN_READ, 0); + if (R_FAILED(rc)) { + mi.FinishGood(rc); + return; + } + + u64 file_size; + rc = FSFILE_GetSize(fd, &file_size); + if (R_FAILED(rc)) { + FSFILE_Close(fd); + mi.FinishGood(rc); + return; + } + + ArticBaseCommon::Buffer* icon_buf = mi.ReserveResultBuffer(0, static_cast(file_size)); + if (!icon_buf) { + FSFILE_Close(fd); + return; + } + + u32 bytes_read; + rc = FSFILE_Read(fd, &bytes_read, 0, icon_buf->data, icon_buf->bufferSize); + if (R_FAILED(rc)) { + FSFILE_Close(fd); + mi.ResizeLastResultBuffer(icon_buf, 0); + mi.FinishGood(rc); + return; + } + + mi.ResizeLastResultBuffer(icon_buf, bytes_read); + FSFILE_Close(fd); + + mi.FinishGood(0); + } + + void Process_ReadIcon(ArticProtocolServer::MethodInterface& mi) { + _Process_ReadExefs(mi, "icon"); + } + + void Process_ReadBanner(ArticProtocolServer::MethodInterface& mi) { + _Process_ReadExefs(mi, "banner"); + } + + void Process_ReadLogo(ArticProtocolServer::MethodInterface& mi) { + _Process_ReadExefs(mi, "logo"); + } + + bool GetFSPath(ArticProtocolServer::MethodInterface& mi, FS_Path& path) { + void* pathPtr; size_t pathSize; + + if (!mi.GetParameterBuffer(pathPtr, pathSize)) + return false; + + path.type = reinterpret_cast(pathPtr)->type; + path.size = reinterpret_cast(pathPtr)->size; + if (pathSize < 8 || path.size != pathSize - 0x8) { + mi.FinishInternalError(); + return false; + } + + path.data = (u8*)pathPtr + 0x8; + return true; + } + + void FSUSER_OpenFileDirectly_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + s32 archiveID; + FS_Path archPath; + FS_Path filePath; + s32 openFlags; + s32 attributes; + + if (good) good = mi.GetParameterS32(archiveID); + if (good) good = GetFSPath(mi, archPath); + if (good) good = GetFSPath(mi, filePath); + if (good) good = mi.GetParameterS32(openFlags); + if (good) good = mi.GetParameterS32(attributes); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + Handle out; + Result res = FSUSER_OpenFileDirectly(&out, (FS_ArchiveID)archiveID, archPath, filePath, openFlags, attributes); + + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* handle_buf = mi.ReserveResultBuffer(0, sizeof(Handle)); + if (!handle_buf) { + FSFILE_Close(out); + return; + } + + *reinterpret_cast(handle_buf->data) = out; + openHandles[(u64)out] = HandleType::FILE; + + mi.FinishGood(res); + } + + void FSUSER_OpenArchive_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + s32 archiveID; + FS_Path archPath; + + if (good) good = mi.GetParameterS32(archiveID); + if (good) good = GetFSPath(mi, archPath); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + FS_Archive out; + Result res = FSUSER_OpenArchive(&out, (FS_ArchiveID)archiveID, archPath); + + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* handle_buf = mi.ReserveResultBuffer(0, sizeof(FS_Archive)); + if (!handle_buf) { + FSUSER_CloseArchive(out); + return; + } + + *reinterpret_cast(handle_buf->data) = out; + openHandles[(u64)out] = HandleType::ARCHIVE; + + mi.FinishGood(res); + } + + void FSUSER_CloseArchive_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + FS_Archive archive; + + if (good) good = mi.GetParameterS64(*reinterpret_cast(&archive)); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + Result res = FSUSER_CloseArchive(archive); + openHandles.erase((u64)archive); + + mi.FinishGood(res); + } + + void FSUSER_OpenFile_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + FS_Archive archive; + FS_Path filePath; + s32 openFlags; + s32 attributes; + + if (good) good = mi.GetParameterS64(*reinterpret_cast(&archive)); + if (good) good = GetFSPath(mi, filePath); + if (good) good = mi.GetParameterS32(openFlags); + if (good) good = mi.GetParameterS32(attributes); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + Handle out; + Result res = FSUSER_OpenFile(&out, archive, filePath, openFlags, attributes); + + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* handle_buf = mi.ReserveResultBuffer(0, sizeof(Handle)); + if (!handle_buf) { + FSFILE_Close(out); + return; + } + + *reinterpret_cast(handle_buf->data) = out; + + // Citra always asks for the size after opening a file, provided it here. + u64 fileSize; + Result res2 = FSFILE_GetSize(out, &fileSize); + if (R_SUCCEEDED(res2)) { + ArticBaseCommon::Buffer* size_buf = mi.ReserveResultBuffer(1, sizeof(u64)); + if (!size_buf) { + FSFILE_Close(out); + return; + } + + *reinterpret_cast(size_buf->data) = fileSize; + } + openHandles[(u64)out] = HandleType::FILE; + + mi.FinishGood(res); + } + + void FSUSER_OpenDirectory_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + FS_Archive archive; + FS_Path dirPath; + + if (good) good = mi.GetParameterS64(*reinterpret_cast(&archive)); + if (good) good = GetFSPath(mi, dirPath); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + Handle out; + Result res = FSUSER_OpenDirectory(&out, archive, dirPath); + + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* handle_buf = mi.ReserveResultBuffer(0, sizeof(Handle)); + if (!handle_buf) { + FSDIR_Close(out); + return; + } + + *reinterpret_cast(handle_buf->data) = out; + openHandles[(u64)out] = HandleType::DIR; + + mi.FinishGood(res); + } + + void FSFILE_Close_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s32 handle; + + if (good) good = mi.GetParameterS32(handle); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + Result res = FSFILE_Close(handle); + openHandles.erase((u64)handle); + + mi.FinishGood(res); + } + + void FSFILE_GetSize_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s32 handle; + + if (good) good = mi.GetParameterS32(handle); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + u64 fileSize; + Result res = FSFILE_GetSize(handle, &fileSize); + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* size_buf = mi.ReserveResultBuffer(0, sizeof(u64)); + if (!size_buf) { + return; + } + + *reinterpret_cast(size_buf->data) = fileSize; + mi.FinishGood(res); + } + + void FSFILE_GetAttributes_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s32 handle; + + if (good) good = mi.GetParameterS32(handle); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + u32 attributes; + Result res = FSFILE_GetAttributes(handle, &attributes); + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* size_buf = mi.ReserveResultBuffer(0, sizeof(u32)); + if (!size_buf) { + return; + } + + *reinterpret_cast(size_buf->data) = attributes; + mi.FinishGood(res); + } + + void FSFILE_Read_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s32 handle, size; + s64 offset; + u32 bytes_read; + + if (good) good = mi.GetParameterS32(handle); + if (good) good = mi.GetParameterS64(offset); + if (good) good = mi.GetParameterS32(size); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + logger.Debug("Read o=0x%08X, l=0x%08X", (u32)offset, (u32)size); + + ArticBaseCommon::Buffer* read_buf = mi.ReserveResultBuffer(0, size); + if (!read_buf) { + return; + } + + Result res = FSFILE_Read(handle, &bytes_read, offset, read_buf->data, read_buf->bufferSize); + if (R_FAILED(res)) { + mi.ResizeLastResultBuffer(read_buf, 0); + mi.FinishGood(res); + return; + } + + mi.ResizeLastResultBuffer(read_buf, bytes_read); + mi.FinishGood(res); + } + + void FSDIR_Read_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s32 handle; + s32 entryCount; + + if (good) good = mi.GetParameterS32(handle); + if (good) good = mi.GetParameterS32(entryCount); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + ArticBaseCommon::Buffer* read_dir_buf = mi.ReserveResultBuffer(0, entryCount * sizeof(FS_DirectoryEntry)); + if (!read_dir_buf) { + return; + } + + u32 entries_read; + Result res = FSDIR_Read(handle, &entries_read, entryCount, reinterpret_cast(read_dir_buf->data)); + if (R_FAILED(res)) { + mi.ResizeLastResultBuffer(read_dir_buf, 0); + mi.FinishGood(res); + return; + } + + mi.ResizeLastResultBuffer(read_dir_buf, entries_read * sizeof(FS_DirectoryEntry)); + mi.FinishGood(res); + } + + void FSDIR_Close_(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s32 handle; + + if (good) good = mi.GetParameterS32(handle); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + Result res = FSDIR_Close(handle); + openHandles.erase((u64)handle); + + mi.FinishGood(res); + } + + void System_IsAzaharInitialSetup(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + if (good) mi.FinishInputParameters(); + + ArticBaseCommon::Buffer* ret_buf = mi.ReserveResultBuffer(0, 4); + if (!ret_buf) { + return; + } + ret_buf->data[0] = INITIAL_SETUP_APP_VERSION; + + mi.FinishGood(0); + } + + void System_GetSystemFile(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + s8 type; + + if (good) good = mi.GetParameterS8(type); + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + if (type < 0 || type > 3) { + mi.FinishGood(-1); + return; + } + + // SecureInfo_A + if (type >= 0 && type <= 2) { + Handle fspxiHandle; + Result res = svcControlService(SERVICEOP_STEAL_CLIENT_SESSION, &fspxiHandle, "PxiFS0"); + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + FSPXI_Archive archive; + res = FSPXI_OpenArchive(fspxiHandle, &archive, ARCHIVE_NAND_CTR_FS, fsMakePath(PATH_EMPTY, "")); + if (R_FAILED(res)) { + svcCloseHandle(fspxiHandle); + mi.FinishGood(res); + return; + } + + const char* files[] = {"/rw/sys/SecureInfo_", "/rw/sys/LocalFriendCodeSeed_", "/private/movable.sed"}; + char file_name[0x20] = {0}; + strcpy(file_name, files[type]); + char* end = file_name + strlen(files[type]); + + if (type == 0 || type == 1) { + *end = 'A'; + } + + FSPXI_File file; + res = FSPXI_OpenFile(fspxiHandle, &file, archive, fsMakePath(PATH_ASCII, file_name), FS_OPEN_READ, 0); + if (R_FAILED(res)) { + *end = 'B'; + res = FSPXI_OpenFile(fspxiHandle, &file, archive, fsMakePath(PATH_ASCII, file_name), FS_OPEN_READ, 0); + if (R_FAILED(res)) { + FSPXI_CloseArchive(fspxiHandle, archive); + svcCloseHandle(fspxiHandle); + mi.FinishGood(res); + return; + } + } + + u64 size = 0; + res = FSPXI_GetFileSize(fspxiHandle, file, &size); + if (R_FAILED(res)) { + FSPXI_CloseFile(fspxiHandle, file); + FSPXI_CloseArchive(fspxiHandle, archive); + svcCloseHandle(fspxiHandle); + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* ret_buf = mi.ReserveResultBuffer(0, (int)size); + if (!ret_buf) { + FSPXI_CloseFile(fspxiHandle, file); + FSPXI_CloseArchive(fspxiHandle, archive); + svcCloseHandle(fspxiHandle); + return; + } + + u32 bytes_read = 0; + res = FSPXI_ReadFile(fspxiHandle, file, &bytes_read, 0, ret_buf->data, (u32)size); + FSPXI_CloseFile(fspxiHandle, file); + FSPXI_CloseArchive(fspxiHandle, archive); + svcCloseHandle(fspxiHandle); + mi.FinishGood(bytes_read != size ? -2 : res); + } else if (type == 3) { + Result res = amInit(); + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + u32 deviceID; + res = AM_GetDeviceId(&deviceID); + amExit(); + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + char filePath[0x50]; + sprintf(filePath, "/luma/backups/%08lX/otp.bin", deviceID); + + Handle file; + + res = FSUSER_OpenFileDirectly(&file, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, ""), fsMakePath(PATH_ASCII, filePath), FS_OPEN_READ, 0); + if (R_FAILED(res)) { + logger.Error("Missing OTP backup on SD card, please update your luma version and/or remove the console battery."); + mi.FinishGood(res); + return; + } + + u64 size = 0; + res = FSFILE_GetSize(file, &size); + if (R_FAILED(res)) { + FSFILE_Close(file); + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* ret_buf = mi.ReserveResultBuffer(0, (int)size); + if (!ret_buf) { + FSFILE_Close(file); + return; + } + + u32 bytes_read = 0; + res = FSFILE_Read(file, &bytes_read, 0, ret_buf->data, (u32)size); + FSFILE_Close(file); + mi.FinishGood(bytes_read != size ? -2 : res); + } + } + + static u32 getle32(const u8* p) + { + return (p[0]<<0) | (p[1]<<8) | (p[2]<<16) | (p[3]<<24); + } + + static u32 lzss_get_decompressed_size(u8* compressed, u32 compressedsize) + { + u8* footer = compressed + compressedsize - 8; + + u32 originalbottom = getle32(footer+4); + + return originalbottom + compressedsize; + } + + static int lzss_decompress(u8* compressed, u32 compressedsize, u8* decompressed, u32 decompressedsize) + { + u8* footer = compressed + compressedsize - 8; + u32 buffertopandbottom = getle32(footer+0); + //u32 originalbottom = getle32(footer+4); + u32 i, j; + u32 out = decompressedsize; + u32 index = compressedsize - ((buffertopandbottom>>24)&0xFF); + u32 segmentoffset; + u32 segmentsize; + u8 control; + u32 stopindex = compressedsize - (buffertopandbottom&0xFFFFFF); + + memset(decompressed, 0, decompressedsize); + memcpy(decompressed, compressed, compressedsize); + + + while(index > stopindex) + { + control = compressed[--index]; + + + for(i=0; i<8; i++) + { + if (index <= stopindex) + break; + + if (index <= 0) + break; + + if (out <= 0) + break; + + if (control & 0x80) + { + if (index < 2) + { + // fprintf(stderr, "Error, compression out of bounds\n"); + goto clean; + } + + index -= 2; + + segmentoffset = compressed[index] | (compressed[index+1]<<8); + segmentsize = ((segmentoffset >> 12)&15)+3; + segmentoffset &= 0x0FFF; + segmentoffset += 2; + + + if (out < segmentsize) + { + // fprintf(stderr, "Error, compression out of bounds\n"); + goto clean; + } + + for(j=0; j= decompressedsize) + { + // fprintf(stderr, "Error, compression out of bounds\n"); + goto clean; + } + + data = decompressed[out+segmentoffset]; + decompressed[--out] = data; + } + } + else + { + if (out < 1) + { + // fprintf(stderr, "Error, compression out of bounds\n"); + goto clean; + } + decompressed[--out] = compressed[--index]; + } + + control <<= 1; + } + } + + return 0; + + clean: + return -1; + } + + void System_GetNIM(ArticProtocolServer::MethodInterface& mi) { + bool good = true; + + if (good) good = mi.FinishInputParameters(); + + if (!good) return; + + Handle file; + u32 archive_path[4] = {0x00002C02, 0x00040130, MEDIATYPE_NAND, 0x0}; + u32 file_path[5] = {0x0, 0x0, 0x2, 0x646F632E, 0x00000065}; + FS_Path archive_path_bin = {PATH_BINARY, 0x10, archive_path}; + FS_Path file_path_bin = {PATH_BINARY, 0x14, file_path}; + Result res = FSUSER_OpenFileDirectly(&file, ARCHIVE_SAVEDATA_AND_CONTENT, archive_path_bin, file_path_bin, FS_OPEN_READ, 0); + if (R_FAILED(res)) { + mi.FinishGood(res); + return; + } + + u64 size = 0; + res = FSFILE_GetSize(file, &size); + if (R_FAILED(res)) { + FSFILE_Close(file); + mi.FinishGood(res); + return; + } + + u8* buffer = (u8*)malloc((size_t)size); + u32 bytes_read = 0; + res = FSFILE_Read(file, &bytes_read, 0, buffer, (u32)size); + FSFILE_Close(file); + if (R_FAILED(res) || bytes_read != size) { + if (bytes_read != size) res = -2; + free(buffer); + mi.FinishGood(res); + return; + } + + ArticBaseCommon::Buffer* ret_buf = mi.ReserveResultBuffer(0, nim_extheader_bin_size); + if (!ret_buf) { + free(buffer); + return; + } + memcpy(ret_buf->data, nim_extheader_bin, nim_extheader_bin_size); + ret_buf = mi.ReserveResultBuffer(1, lzss_get_decompressed_size(buffer, (u32)size)); + if (!ret_buf) { + free(buffer); + return; + } + lzss_decompress(buffer, (u32)size, (u8*)ret_buf->data, ret_buf->bufferSize); + free(buffer); + + u64 checksum = 0; + u64* start = (u64*)(ret_buf->data), *end = (u64*)((uintptr_t)(ret_buf->data + ret_buf->bufferSize) & ~7); + while (start != end) checksum = (checksum + *start++) * 0x6500000065ULL; + if (checksum != 0x50F9D326AB2239E9ULL) { + logger.Error("Invalid NIM checksum. Please ensure your console is on the latest version"); + mi.ResizeLastResultBuffer(ret_buf, 0); + mi.FinishGood(-3); + return; + } + + mi.FinishGood(0); + } + + template + constexpr auto& METHOD_NAME(char const (&s)[N]) { + static_assert(N < sizeof(ArticBaseCommon::RequestPacket::method), "String exceeds 32 bytes!"); + return s; + } + + std::map functionHandlers = { + {METHOD_NAME("Process_GetTitleID"), Process_GetTitleID}, + {METHOD_NAME("Process_GetProductInfo"), Process_GetProductInfo}, + {METHOD_NAME("Process_GetExheader"), Process_GetExheader}, + {METHOD_NAME("Process_ReadCode"), Process_ReadCode}, + {METHOD_NAME("Process_ReadIcon"), Process_ReadIcon}, + {METHOD_NAME("Process_ReadBanner"), Process_ReadBanner}, + {METHOD_NAME("Process_ReadLogo"), Process_ReadLogo}, + {METHOD_NAME("FSUSER_OpenFileDirectly"), FSUSER_OpenFileDirectly_}, + {METHOD_NAME("FSUSER_OpenArchive"), FSUSER_OpenArchive_}, + {METHOD_NAME("FSUSER_CloseArchive"), FSUSER_CloseArchive_}, + {METHOD_NAME("FSUSER_OpenFile"), FSUSER_OpenFile_}, + {METHOD_NAME("FSUSER_OpenDirectory"), FSUSER_OpenDirectory_}, + {METHOD_NAME("FSFILE_Close"), FSFILE_Close_}, + {METHOD_NAME("FSFILE_GetAttributes"), FSFILE_GetAttributes_}, + {METHOD_NAME("FSFILE_GetSize"), FSFILE_GetSize_}, + {METHOD_NAME("FSFILE_Read"), FSFILE_Read_}, + {METHOD_NAME("FSDIR_Read"), FSDIR_Read_}, + {METHOD_NAME("FSDIR_Close"), FSDIR_Close_}, + + {METHOD_NAME("System_IsAzaharInitialSetup"), System_IsAzaharInitialSetup}, + {METHOD_NAME("System_GetSystemFile"), System_GetSystemFile}, + {METHOD_NAME("System_GetNIM"), System_GetNIM}, + }; + + bool obtainExheader() { + Result loaderInitCustom(void); + void loaderExitCustom(void); + Result LOADER_GetLastApplicationProgramInfo(ExHeader_Info* exheaderInfo); + + + Result res = loaderInitCustom(); + if (R_SUCCEEDED(res)) res = LOADER_GetLastApplicationProgramInfo(&lastAppExheader); + loaderExitCustom(); + + if (R_FAILED(res)) { + logger.Error("Failed to get ExHeader. Luma3DS may be outdated."); + return false; + } + + return true; + } + + static bool closeHandles() { + auto CloseHandle = [](u64 handle, HandleType type) { + switch (type) + { + case HandleType::FILE: + logger.Debug("Call pending FSFILE_Close"); + FSFILE_Close((Handle)handle); + break; + case HandleType::DIR: + logger.Debug("Call pending FSDIR_Close"); + FSDIR_Close((Handle)handle); + break; + case HandleType::ARCHIVE: + logger.Debug("Call pending FSUSER_CloseArchive"); + FSUSER_CloseArchive((FS_Archive)handle); + break; + default: + break; + } + }; + for (auto it = openHandles.begin(); it != openHandles.end(); it++) { + CloseHandle(it->first, it->second); + } + openHandles.clear(); + return true; + } + + std::vector setupFunctions { + obtainExheader, + }; + + std::vector destructFunctions { + closeHandles, + }; +} diff --git a/plugin/sources/BCLIM.cpp b/plugin/sources/BCLIM.cpp new file mode 100644 index 0000000..7e7101c --- /dev/null +++ b/plugin/sources/BCLIM.cpp @@ -0,0 +1,150 @@ +#include "BCLIM.hpp" + +namespace CTRPluginFramework { + + static inline int ColorClamp(int Color) + { + if (Color > 255) Color = 255; + if (Color < 0) Color = 0; + return Color; + } + + const u8 BCLIM::textureTileOrder[] = + { + 0, 1, 4, 5, + 2, 3, 6, 7, + + 8, 9, 12, 13, + 10, 11, 14, 15 + }; + + const u8 BCLIM::etc1Modifiers[][2] = + { + { 2, 8 }, + { 5, 17 }, + { 9, 29 }, + { 13, 42 }, + { 18, 60 }, + { 24, 80 }, + { 33, 106 }, + { 47, 183 } + }; + + Color BCLIM::OpaqueBlendFunc(const Color& dst, const Color& src) { + return dst; + } + + static Color ReadPixel(void* fb, int posX, int posY) { + constexpr u32 _bytesPerPixel = 2; + constexpr u32 _rowSize = 240; + u32 offset = (_rowSize - 1 - posY + posX * _rowSize) * _bytesPerPixel; + union + { + u16 u; + u8 b[2]; + } half; + half.u = *reinterpret_cast((u32)fb + offset); + Color c; + c.r = (half.u >> 8) & 0xF8; + c.g = (half.u >> 3) & 0xFC; + c.b = (half.u << 3) & 0xF8; + c.a = 255; + return c; + } + static void WritePixel(void* fb, int posX, int posY, const Color& c) { + constexpr u32 _bytesPerPixel = 2; + constexpr u32 _rowSize = 240; + u32 offset = (_rowSize - 1 - posY + posX * _rowSize) * _bytesPerPixel; + union + { + u16 u; + u8 b[2]; + } half; + half.u = (c.r & 0xF8) << 8; + half.u |= (c.g & 0xFC) << 3; + half.u |= (c.b & 0xF8) >> 3; + *reinterpret_cast((u32)fb + offset) = half.u; + } + + void BCLIM::RenderInterfaceBackend(void* usrData, bool isRead, Color* c, int posX, int posY) { + if (isRead) { + *c = ReadPixel(gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL), posX, posY); + } else { + WritePixel(gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL), posX, posY, *c); + } + } + + static bool FastContains(const Rect& rect, Vector point) { + return point.x >= rect.leftTop.x && point.x < (rect.leftTop.x + rect.size.x) && + point.y >= rect.leftTop.y && point.y < (rect.leftTop.y + rect.size.y); + } + + void BCLIM::Render(const Rect& position, std::pair backend, const Rect& crop, const Rect& limits, std::pair colorBlender) { + auto mappingScale = [](const Rect& position, int x, int y, int w, int h) { + int posX = position.leftTop.x; + int posY = position.leftTop.y; + float progX = x/(float)w; + float progY = y/(float)h; + + return Vector(posX + position.size.x * progX, posY + position.size.y * progY); + }; + auto mappingDirect = [](const Rect& position, int x, int y, int w, int h) { + return Vector(position.leftTop.x + x, position.leftTop.y + y); + }; + Vector(*mapping)(const Rect& position, int x, int y, int w, int h); + Color current; + + if (position.size.x == header->imag.width && position.size.y == header->imag.height) + mapping = mappingDirect; + else + mapping = mappingScale; + + switch (header->imag.format) { + case TextureFormat::L8: + case TextureFormat::A8: + case TextureFormat::LA4: + case TextureFormat::LA8: + case TextureFormat::HILO8: + case TextureFormat::RGB8: + case TextureFormat::RGBA5551: + case TextureFormat::RGBA8: + case TextureFormat::ETC1: + case TextureFormat::L4: + case TextureFormat::A4: + case TextureFormat::RGBA4: + case TextureFormat::ETC1A4: + break; + case TextureFormat::RGB565: + { + int offs = 0; + Vector prevPos(-1, -1); + for (int y = 0; y < header->imag.height; y+=8) { + for (int x = 0; x < header->imag.width; x+=8) { + for (int i = 0; i < 64; i++) { + int x2 = i % 8; + if (x + x2 >= crop.size.x || x + x2 >= header->imag.width) continue; + int y2 = i / 8; + if (y + y2 >= crop.size.y || y + y2 >= header->imag.height) continue; + auto drawPos = mapping(position, x + x2, y + y2, header->imag.width, header->imag.height); + if (!FastContains(limits, drawPos)) continue; + if (drawPos.x != prevPos.x || drawPos.y != prevPos.y) { + prevPos = drawPos; + int pos = textureTileOrder[x2 % 4 + y2 % 4 * 4] + 16 * (x2 / 4) + 32 * (y2 / 4); + u16 pixel = GetDataAt(offs + pos * 2); + u8 b = (u8)((pixel & 0x1F) << 3); + u8 g = (u8)((pixel & 0x7E0) >> 3); + u8 r = (u8)((pixel & 0xF800) >> 8); + if (colorBlender.first) + backend.second(backend.first, true, ¤t, drawPos.x, drawPos.y); + Color finalcolor = colorBlender.second(Color(r, g, b), current); + backend.second(backend.first, false, &finalcolor, drawPos.x, drawPos.y); + } + } + offs += 64 * 2; + } + } + } + break; + } + } +} \ No newline at end of file diff --git a/plugin/sources/CTRPluginFramework/Color.cpp b/plugin/sources/CTRPluginFramework/Color.cpp new file mode 100644 index 0000000..7ba73de --- /dev/null +++ b/plugin/sources/CTRPluginFramework/Color.cpp @@ -0,0 +1,158 @@ +#include "CTRPluginFramework/Color.hpp" +#include + +namespace CTRPluginFramework +{ + Color& Color::Fade(float fading) + { + if (fading > 1.0f || fading < -1.0f) + return *this; + + if (fading > 0.0f) + { + float tint = 1.f - fading; + r = std::min((int)(255 - (255 - r) * tint), 255); + g = std::min((int)(255 - (255 - g) * tint), 255); + b = std::min((int)(255 - (255 - b) * tint), 255); + } + else + { + float shade = 1.f + fading; + + r *= shade; + g *= shade; + b *= shade; + } + return *this; + } + + Color Color::Blend(const Color &color, BlendMode mode) const + { + // This is background, color is foreground + Color ret; + unsigned int _r; + unsigned int _g; + unsigned int _b; + unsigned int _a; + float forealpha = (float)color.a / 255.f; + float minusForeAlpha = 1.f - forealpha; + + switch (mode) + { + case BlendMode::Alpha: + _r = (forealpha * (float)color.r) + ((float)r * minusForeAlpha); + _g = (forealpha * (float)color.g) + ((float)g * minusForeAlpha); + _b = (forealpha * (float)color.b) + ((float)b * minusForeAlpha); + _a = color.a * a; + ret.r = std::min(_r, 255u); + ret.g = std::min(_g, 255u); + ret.b = std::min(_b, 255u); + ret.a = std::min(_a, 255u); + break; + case BlendMode::Add: + _r = a * r / 255 + 255 * color.r / 255; + _g = a * g / 255 + 255 * color.g / 255; + _b = a * b / 255 + 255 * color.b / 255; + _a = a + color.a; + ret.r = std::min(_r, 255u); + ret.g = std::min(_g, 255u); + ret.b = std::min(_b, 255u); + ret.a = std::min(_a, 255u); + break; + case BlendMode::Sub: + _r = a * r / 255 - 255 * color.r / 255; + _g = a * g / 255 - 255 * color.g / 255; + _b = a * b / 255 - 255 * color.b / 255; + _a = a - color.a; + ret.r = std::max(_r, 0u); + ret.g = std::max(_g, 0u); + ret.b = std::max(_b, 0u); + ret.a = std::max(_a, 0u); + break; + case BlendMode::Mul: + ret = *this * color; + break; + default: + ret = color; + break; + } + return (ret); + } + + bool Color::operator < (const Color &right) const + { + return (( r < right.r) + && (b < right.b) + && (g < right.g)); + } + + bool Color::operator <= (const Color &right) const + { + return (( r <= right.r) + && (b <= right.b) + && (g <= right.g)); + } + + bool Color::operator > (const Color &right) const + { + return (( r > right.r) + && (b > right.b) + && (g > right.g)); + } + + bool Color::operator >= (const Color &right) const + { + return (( r >= right.r) + && (b >= right.b) + && (g >= right.g)); + } + + Color Color::operator+(const Color& right) const + { + u8 _r(std::min(r + right.r, 255)); + u8 _g(std::min(g + right.g, 255)); + u8 _b(std::min(b + right.b, 255)); + u8 _a(std::min(a + right.a, 255)); + + return (Color(_r, _g, _b, _a)); + + } + + Color Color::operator-(const Color& right) const + { + u8 _r(std::max(r - right.r, 0)); + u8 _g(std::max(g - right.g, 0)); + u8 _b(std::max(b - right.b, 0)); + u8 _a(std::max(a - right.a, 0)); + + return (Color(_r, _g, _b, _a)); + } + + Color Color::operator*(const Color& right) const + { + u8 _r(r * right.r / 255); + u8 _g(g * right.g / 255); + u8 _b(b * right.b / 255); + u8 _a(a * right.a / 255); + + return (Color(_r, _g, _b, _a)); + } + + Color &Color::operator+=(const Color& right) + { + *this = *this + right; + return (*this); + } + + Color &Color::operator-=(const Color& right) + { + *this = *this - right; + return (*this); + } + + Color &Color::operator*=(const Color& right) + { + *this = *this * right; + return (*this); + } + } diff --git a/plugin/sources/CTRPluginFramework/Time.cpp b/plugin/sources/CTRPluginFramework/Time.cpp new file mode 100644 index 0000000..c928203 --- /dev/null +++ b/plugin/sources/CTRPluginFramework/Time.cpp @@ -0,0 +1,26 @@ +#include "3ds/types.h" + +#include "CTRPluginFramework/Time.hpp" + +namespace CTRPluginFramework +{ + const Time Time::Zero; + + float Time::AsSeconds(void) const + { + return (_ticks / (float)TicksPerSecond); + } + + + int Time::AsMilliseconds(void) const + { + return static_cast(_ticks / (TicksPerSecond / 1000.f)); + } + + + s64 Time::AsMicroseconds(void) const + { + return static_cast(_ticks / (TicksPerSecond / 1000000.f)); + } + +} diff --git a/plugin/sources/csvc.s b/plugin/sources/csvc.s new file mode 100644 index 0000000..da69875 --- /dev/null +++ b/plugin/sources/csvc.s @@ -0,0 +1,122 @@ +@ This paricular file is licensed under the following terms: + +@ This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable +@ for any damages arising from the use of this software. +@ +@ Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it +@ and redistribute it freely, subject to the following restrictions: +@ +@ The origin of this software must not be misrepresented; you must not claim that you wrote the original software. +@ If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +@ +@ Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +@ This notice may not be removed or altered from any source distribution. + +.arm +.balign 4 + +.macro SVC_BEGIN name + .section .text.\name, "ax", %progbits + .global \name + .type \name, %function + .align 2 + .cfi_startproc +\name: +.endm + +.macro SVC_END + .cfi_endproc +.endm + +SVC_BEGIN svcCustomBackdoor + svc 0x80 + bx lr +SVC_END + +SVC_BEGIN svcConvertVAToPA + svc 0x90 + bx lr +SVC_END + +SVC_BEGIN svcFlushDataCacheRange + svc 0x91 + bx lr +SVC_END + +SVC_BEGIN svcFlushEntireDataCache + svc 0x92 + bx lr +SVC_END + +SVC_BEGIN svcInvalidateInstructionCacheRange + svc 0x93 + bx lr +SVC_END + +SVC_BEGIN svcInvalidateEntireInstructionCache + svc 0x94 + bx lr +SVC_END + +SVC_BEGIN svcMapProcessMemoryEx + str r4, [sp, #-4]! + ldr r4, [sp, #4] + svc 0xA0 + ldr r4, [sp], #4 + bx lr +SVC_END + +SVC_BEGIN svcUnmapProcessMemoryEx + svc 0xA1 + bx lr +SVC_END + +SVC_BEGIN svcControlMemoryEx + push {r0, r4, r5} + ldr r0, [sp, #0xC] + ldr r4, [sp, #0xC+0x4] + ldr r5, [sp, #0xC+0x8] + svc 0xA2 + pop {r2, r4, r5} + str r1, [r2] + bx lr +SVC_END + +SVC_BEGIN svcControlMemoryUnsafe + str r4, [sp, #-4]! + ldr r4, [sp, #4] + svc 0xA3 + ldr r4, [sp], #4 + bx lr +SVC_END + +SVC_BEGIN svcFreeMemory + svc 0xA3 + bx lr +SVC_END + +SVC_BEGIN svcControlService + svc 0xB0 + bx lr +SVC_END + +SVC_BEGIN svcCopyHandle + str r0, [sp, #-4]! + svc 0xB1 + ldr r2, [sp], #4 + str r1, [r2] + bx lr +SVC_END + +SVC_BEGIN svcTranslateHandle + str r0, [sp, #-4]! + svc 0xB2 + ldr r2, [sp], #4 + str r1, [r2] + bx lr +SVC_END + +SVC_BEGIN svcControlProcess + svc 0xB3 + bx lr +SVC_END diff --git a/plugin/sources/loaderCustom.cpp b/plugin/sources/loaderCustom.cpp new file mode 100644 index 0000000..1eec012 --- /dev/null +++ b/plugin/sources/loaderCustom.cpp @@ -0,0 +1,41 @@ +#include "3ds.h" + +namespace ArticBaseFunctions { + + static Handle loaderHandleCustom; + static int loaderRefCountCustom; + Result loaderInitCustom(void) + { + Result res; + if (AtomicPostIncrement(&loaderRefCountCustom)) return 0; + res = srvGetServiceHandle(&loaderHandleCustom, "Loader"); + if (R_FAILED(res)) AtomicDecrement(&loaderRefCountCustom); + return res; + } + + void loaderExitCustom(void) + { + if (AtomicDecrement(&loaderRefCountCustom)) return; + svcCloseHandle(loaderHandleCustom); + } + + Result LOADER_GetLastApplicationProgramInfo(ExHeader_Info* exheaderInfo) + { + Result ret = 0; + u32 *cmdbuf = getThreadCommandBuffer(); + u32 *staticbufs = getThreadStaticBuffers(); + + cmdbuf[0] = IPC_MakeHeader(0x102, 0, 0); + + u32 staticbufscpy[2] = {staticbufs[0], staticbufs[1]}; + staticbufs[0] = IPC_Desc_StaticBuffer(0x400, 0); + staticbufs[1] = (u32)exheaderInfo; + + if(R_FAILED(ret = svcSendSyncRequest(loaderHandleCustom))) return ret; + + staticbufs[0] = staticbufscpy[0]; + staticbufs[1] = staticbufscpy[1]; + + return (Result)cmdbuf[1]; + } +} diff --git a/plugin/sources/logo.c b/plugin/sources/logo.c new file mode 100644 index 0000000..e6082d9 --- /dev/null +++ b/plugin/sources/logo.c @@ -0,0 +1,2057 @@ +/* Generated by bin2c, do not edit manually */ + +/* Contents of file .\data\logo.bin */ +const long int __data_logo_bin_size = 32808; +const unsigned char __data_logo_bin[32808] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, 0x92, 0x94, + 0x7D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0x1C, 0xE7, 0x5D, 0xEF, 0x3C, 0xE7, 0xFB, 0xDE, 0xFB, 0xDE, + 0x96, 0xB5, 0x0C, 0x63, 0x20, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x8E, 0x73, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0xFB, 0xDE, 0x5D, 0xEF, 0x7D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, + 0x34, 0xA5, 0x79, 0xCE, 0x00, 0x00, 0x86, 0x31, 0x9A, 0xD6, 0xBA, 0xD6, 0x10, 0x84, 0x38, 0xC6, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, + 0xDB, 0xDE, 0xFB, 0xDE, 0x59, 0xCE, 0x9A, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0x1C, 0xE7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, + 0x7D, 0xEF, 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0xF7, 0xBD, 0x61, 0x08, 0x0C, 0x63, 0x00, 0x00, + 0x1C, 0xE7, 0xBA, 0xD6, 0xFB, 0xDE, 0xD7, 0xBD, 0x04, 0x21, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x04, 0x21, 0x00, 0x00, 0x78, 0xCE, 0xAA, 0x52, 0x20, 0x00, 0xDE, 0xFF, 0x3B, 0xE7, + 0x0F, 0x84, 0xFE, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0x34, 0xA5, 0xDB, 0xDE, 0xF3, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDB, 0xDE, 0x14, 0xA5, 0xDB, 0xDE, 0x96, 0xB5, 0x20, 0x00, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, + 0x58, 0xCE, 0xFF, 0xFF, 0x99, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x38, 0xC6, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x74, 0xAD, 0x48, 0x4A, 0x00, 0x00, 0x45, 0x29, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0x85, 0x31, 0xFF, 0xFF, 0x5B, 0xEF, + 0x51, 0x8C, 0x18, 0xC6, 0x00, 0x00, 0x28, 0x42, 0x59, 0xCE, 0x9A, 0xD6, 0x75, 0xAD, 0x38, 0xC6, + 0x00, 0x00, 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0xC3, 0x18, 0x51, 0x8C, 0x00, 0x00, 0x20, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0xDA, 0xDE, 0xFF, 0xFF, + 0xFE, 0xFF, 0xF6, 0xBD, 0xFE, 0xFF, 0xFF, 0xFF, 0x20, 0x00, 0x00, 0x00, 0xB9, 0xD6, 0x07, 0x42, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x1B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xDB, 0xDE, 0x1C, 0xE7, 0x79, 0xCE, 0xDB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x5D, 0xEF, + 0xF7, 0xBD, 0x59, 0xCE, 0x6D, 0x6B, 0xF7, 0xBD, 0xBA, 0xD6, 0xFB, 0xDE, 0x59, 0xCE, 0xBA, 0xD6, + 0xBE, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, 0x20, 0x00, 0xD7, 0xBD, 0x38, 0xC6, 0xEB, 0x5A, 0xD7, 0xBD, + 0x69, 0x4A, 0x00, 0x00, 0x1B, 0xE7, 0x07, 0x42, 0x00, 0x00, 0x4D, 0x6B, 0x00, 0x00, 0x20, 0x00, + 0x9A, 0xD6, 0xFB, 0xDE, 0x38, 0xC6, 0xBA, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0xD7, 0xBD, 0x59, 0xCE, 0x30, 0x84, 0xF7, 0xBD, 0xBA, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x3C, 0xE7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xDB, 0xDE, 0x18, 0xC6, 0xDB, 0xDE, 0x59, 0xCE, 0xC3, 0x18, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, + 0xDB, 0xDE, 0x59, 0xCE, 0xDB, 0xDE, 0x79, 0xCE, 0x49, 0x4A, 0x00, 0x00, 0x0C, 0x63, 0x00, 0x00, + 0xF2, 0x9C, 0xFF, 0xFF, 0x0F, 0x84, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCA, 0x5A, 0xDD, 0xFF, 0xA6, 0x31, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x79, 0xCE, 0xCF, 0x7B, 0x00, 0x00, 0x51, 0x8C, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0x92, 0x94, 0x00, 0x00, 0xD3, 0x9C, 0x00, 0x00, + 0x00, 0x00, 0x1B, 0xE7, 0x00, 0x00, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x99, 0xD6, 0x00, 0x00, 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0x7C, 0xEF, 0x17, 0xC6, 0x13, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xCE, 0x7B, 0xFF, 0xFF, 0x17, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x5C, 0xEF, 0xFE, 0xFF, 0x74, 0xAD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCE, 0x7B, 0xBD, 0xF7, 0xF2, 0x9C, 0x99, 0xD6, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x99, 0xD6, 0xF3, 0x9C, 0xBD, 0xF7, 0xEF, 0x7B, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, + 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xEF, 0x7B, 0xFF, 0xFF, 0x1B, 0xE7, + 0xE3, 0x18, 0x34, 0xA5, 0x00, 0x00, 0x49, 0x4A, 0xF7, 0xBD, 0x79, 0xCE, 0xB6, 0xB5, 0x38, 0xC6, + 0x00, 0x00, 0x20, 0x00, 0xC2, 0x18, 0x00, 0x00, 0x30, 0x84, 0xD7, 0xBD, 0x65, 0x29, 0x75, 0xAD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x34, 0xA5, 0x00, 0x00, 0x7C, 0xEF, 0xC7, 0x39, 0x00, 0x00, 0xCF, 0x7B, 0x00, 0x00, 0x65, 0x29, + 0xFF, 0xFF, 0x54, 0xAD, 0xFF, 0xFF, 0x3B, 0xE7, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, + 0xDB, 0xDE, 0x3C, 0xE7, 0x9A, 0xD6, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, + 0x59, 0xCE, 0xDB, 0xDE, 0x18, 0xC6, 0x9A, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xB6, 0xB5, 0x59, 0xCE, 0x75, 0xAD, 0x18, 0xC6, 0xBA, 0xD6, 0x3C, 0xE7, 0x79, 0xCE, 0xFB, 0xDE, + 0x10, 0x84, 0xB6, 0xB5, 0x08, 0x42, 0x75, 0xAD, 0x59, 0xCE, 0xDB, 0xDE, 0x18, 0xC6, 0x9A, 0xD6, + 0x7D, 0xEF, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, + 0x9E, 0xF7, 0x7D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0xFB, 0xDE, + 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, + 0x3C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, 0xDB, 0xDE, 0x1C, 0xE7, 0x1C, 0xE7, 0xBA, 0xD6, 0x9A, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, + 0xFB, 0xDE, 0xFB, 0xDE, 0x9A, 0xD6, 0x9A, 0xD6, 0xFB, 0xDE, 0x1C, 0xE7, 0x9A, 0xD6, 0x9A, 0xD6, + 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0x9E, 0xF7, + 0x1C, 0xE7, 0x3C, 0xE7, 0xBA, 0xD6, 0xDB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0x1C, 0xE7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x5D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, 0x6D, 0x6B, + 0x3C, 0xE7, 0x79, 0xCE, 0x1C, 0xE7, 0x49, 0x4A, 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x7D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0xFB, 0xDE, 0x3C, 0xE7, 0x1C, 0xE7, 0xDB, 0xDE, 0xBA, 0xD6, + 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, + 0x1C, 0xE7, 0x1C, 0xE7, 0xBA, 0xD6, 0x9A, 0xD6, 0x1C, 0xE7, 0x1C, 0xE7, 0x9A, 0xD6, 0x9A, 0xD6, + 0x38, 0xC6, 0x51, 0x8C, 0x82, 0x10, 0x00, 0x00, 0x0C, 0x63, 0x8A, 0x52, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x8D, 0x73, 0x99, 0xD6, 0x08, 0x42, 0xCA, 0x5A, 0x9D, 0xF7, 0xDD, 0xFF, + 0x69, 0x4A, 0x8A, 0x52, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x63, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, + 0xEB, 0x5A, 0xAA, 0x52, 0xDD, 0xFF, 0xBD, 0xF7, 0xE7, 0x39, 0x00, 0x00, 0x9C, 0xF7, 0x1B, 0xE7, + 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, + 0x1C, 0xE7, 0x1C, 0xE7, 0xBA, 0xD6, 0xBA, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0xFB, 0xDE, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x5D, 0xEF, 0x7D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x5D, 0xEF, + 0xF3, 0x9C, 0xD7, 0xBD, 0x00, 0x00, 0xA2, 0x10, 0x59, 0xCE, 0x79, 0xCE, 0xC7, 0x39, 0x8E, 0x73, + 0x00, 0x00, 0x00, 0x00, 0x37, 0xC6, 0xD2, 0x9C, 0x00, 0x00, 0x00, 0x00, 0xCA, 0x5A, 0x00, 0x00, + 0x9A, 0xD6, 0xBA, 0xD6, 0x55, 0xAD, 0x38, 0xC6, 0xDB, 0xDE, 0xFB, 0xDE, 0x79, 0xCE, 0x9A, 0xD6, + 0x41, 0x08, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x10, 0x84, 0xD7, 0xBD, 0x00, 0x00, 0xE3, 0x18, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x1C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x5D, 0xEF, + 0x38, 0xC6, 0x79, 0xCE, 0x4D, 0x6B, 0xB6, 0xB5, 0xBA, 0xD6, 0xFB, 0xDE, 0x38, 0xC6, 0x79, 0xCE, + 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x5D, 0xEF, 0xBA, 0xD6, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, + 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, 0x9A, 0xD6, 0xF3, 0x9C, 0x00, 0x00, 0xD3, 0x9C, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0xB2, 0x94, 0x00, 0x00, 0x30, 0x84, 0x00, 0x00, + 0x00, 0x00, 0x37, 0xC6, 0x00, 0x00, 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x99, 0xD6, 0x00, 0x00, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0x79, 0xCE, 0xDB, 0xDE, 0x79, 0xCE, 0x8E, 0x73, 0x00, 0x00, 0x8A, 0x52, 0x00, 0x00, + 0xDB, 0xDE, 0x59, 0xCE, 0xBA, 0xD6, 0x96, 0xB5, 0x65, 0x29, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, + 0x61, 0x08, 0x3B, 0xE7, 0x48, 0x4A, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCE, 0x7B, 0xFE, 0xFF, 0x34, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xB2, 0x94, 0xFF, 0xFF, 0x17, 0xC6, 0xDA, 0xDE, 0xFF, 0xFF, 0x95, 0xB5, 0xFF, 0xFF, + 0xFF, 0xFF, 0x1B, 0xE7, 0xFE, 0xFF, 0xBD, 0xF7, 0x71, 0x8C, 0xFE, 0xFF, 0x0F, 0x84, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x91, 0x94, 0x1B, 0xE7, 0x74, 0xAD, 0x78, 0xCE, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x37, 0xC6, 0x95, 0xB5, 0xFA, 0xDE, 0xB2, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0x00, 0x00, 0x58, 0xCE, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xC6, 0x39, 0xFE, 0xFF, 0x0F, 0x84, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFA, 0xDE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0x82, 0x10, 0xF3, 0x9C, 0x00, 0x00, 0x8E, 0x73, 0xD7, 0xBD, 0x79, 0xCE, 0x96, 0xB5, 0x38, 0xC6, + 0x00, 0x00, 0x08, 0x42, 0x00, 0x00, 0xC3, 0x18, 0x75, 0xAD, 0x18, 0xC6, 0x14, 0xA5, 0xD7, 0xBD, + 0xDB, 0xDE, 0x5D, 0xEF, 0xBA, 0xD6, 0x3C, 0xE7, 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0x9A, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xFB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x9E, 0xF7, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x8C, 0xB6, 0xB5, 0x2C, 0x63, 0x75, 0xAD, + 0x28, 0x42, 0x00, 0x00, 0xEE, 0x7B, 0x00, 0x00, 0x08, 0x42, 0x55, 0xAD, 0x04, 0x21, 0x34, 0xA5, + 0x38, 0xC6, 0xDB, 0xDE, 0x18, 0xC6, 0x9A, 0xD6, 0x1C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0xF7, 0xBD, 0x79, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, 0xDB, 0xDE, 0x3C, 0xE7, 0xBA, 0xD6, 0x1C, 0xE7, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, + 0x5D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x3C, 0xE7, 0x5D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0xFB, 0xDE, + 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x5D, 0xEF, 0x3C, 0xE7, 0x1C, 0xE7, 0xDB, 0xDE, + 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, 0x38, 0xC6, 0x9A, 0xD6, 0xF3, 0x9C, 0xEB, 0x5A, 0x20, 0x00, + 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, + 0x9E, 0xF7, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, + 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, + 0xDB, 0xDE, 0xBA, 0xD6, 0xF7, 0xBD, 0x4D, 0x6B, 0x18, 0xC6, 0xCF, 0x7B, 0xC3, 0x18, 0x00, 0x00, + 0xFB, 0xDE, 0xBA, 0xD6, 0x9A, 0xD6, 0xEF, 0x7B, 0x18, 0xC6, 0x4D, 0x6B, 0xC3, 0x18, 0x00, 0x00, + 0x86, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x37, 0xC6, + 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8D, 0x73, 0x58, 0xCE, + 0x8D, 0x73, 0x98, 0xD6, 0xDE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFB, 0xDE, 0xDB, 0xDE, 0x9A, 0xD6, 0x14, 0xA5, 0xBA, 0xD6, 0x59, 0xCE, 0xEB, 0x5A, 0x04, 0x21, + 0x65, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0xEF, 0x7B, + 0x55, 0xAD, 0xEF, 0x7B, 0x20, 0x00, 0x00, 0x00, 0xEB, 0x5A, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0xFA, 0xDE, 0x28, 0x42, 0x2C, 0x63, 0x9D, 0xF7, 0xDE, 0xFF, + 0xEB, 0x5A, 0x95, 0xB5, 0xBD, 0xF7, 0xFF, 0xFF, 0x5B, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0xDE, 0xFF, + 0xC7, 0x39, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, 0xEB, 0x5A, 0x00, 0x00, 0x00, 0x00, + 0xCE, 0x7B, 0xCE, 0x7B, 0xFE, 0xFF, 0xFE, 0xFF, 0x0B, 0x63, 0xE7, 0x39, 0xDE, 0xFF, 0x9C, 0xF7, + 0x10, 0x84, 0x96, 0xB5, 0x00, 0x00, 0x41, 0x08, 0x79, 0xCE, 0x9A, 0xD6, 0x08, 0x42, 0x14, 0xA5, + 0x00, 0x00, 0x00, 0x00, 0xB9, 0xD6, 0xD2, 0x9C, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xD9, 0xDE, 0x07, 0x42, 0xFF, 0xFF, 0x70, 0x8C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDD, 0xFF, 0x0B, 0x63, 0x99, 0xD6, 0x00, 0x00, + 0xDB, 0xDE, 0x1C, 0xE7, 0x79, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, + 0x8E, 0x73, 0x59, 0xCE, 0x00, 0x00, 0x51, 0x8C, 0xBA, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, + 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0x5D, 0xEF, 0x9E, 0xF7, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x00, 0x00, 0xC7, 0x39, 0x00, 0x00, 0x24, 0x21, 0x18, 0xC6, 0x9A, 0xD6, 0xD7, 0xBD, 0x79, 0xCE, + 0x00, 0x00, 0xA6, 0x31, 0x00, 0x00, 0x0C, 0x63, 0xB6, 0xB5, 0x59, 0xCE, 0x96, 0xB5, 0x38, 0xC6, + 0xFB, 0xDE, 0x5D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x3C, 0xE7, 0xBA, 0xD6, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, + 0x18, 0xC6, 0x41, 0x08, 0x18, 0xC6, 0x41, 0x08, 0x00, 0x00, 0x91, 0x94, 0x00, 0x00, 0xF3, 0x9C, + 0xDB, 0xDE, 0x28, 0x42, 0xDB, 0xDE, 0x96, 0xB5, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x10, 0x84, 0x00, 0x00, 0x18, 0xC6, 0x69, 0x4A, + 0x1C, 0xE7, 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0x34, 0xA5, 0x79, 0xCE, 0xF7, 0xBD, + 0xDE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x58, 0xCE, 0xFF, 0xFF, 0xC6, 0x39, 0x5B, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x58, 0xCE, 0x99, 0xD6, + 0x00, 0x00, 0x0F, 0x84, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, + 0x82, 0x10, 0x00, 0x00, 0x49, 0x4A, 0x00, 0x00, 0x2F, 0x84, 0xFE, 0xFF, 0xC6, 0x39, 0x7C, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0x54, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xDA, 0xDE, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x13, 0xA5, 0x28, 0x42, 0xFF, 0xFF, 0x9D, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x17, 0xC6, 0x2C, 0x63, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x91, 0x94, 0x7C, 0xEF, 0x58, 0xCE, 0x6D, 0x6B, 0xFF, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xFF, 0xFF, + 0xFF, 0xFF, 0x5B, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, 0xCE, 0x7B, 0xD6, 0xBD, 0xDD, 0xFF, 0xB1, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x13, 0xA5, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x6B, 0xF7, 0xBD, 0x00, 0x00, 0x45, 0x29, + 0x37, 0xC6, 0xEB, 0x5A, 0xFF, 0xFF, 0xBD, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x74, 0xAD, 0x00, 0x00, + 0x38, 0xC6, 0x9A, 0xD6, 0xB2, 0x94, 0x18, 0xC6, 0xDB, 0xDE, 0x1C, 0xE7, 0x79, 0xCE, 0xBA, 0xD6, + 0x41, 0x08, 0x6D, 0x6B, 0x00, 0x00, 0x00, 0x00, 0xF7, 0xBD, 0x59, 0xCE, 0x69, 0x4A, 0xD7, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x69, 0x4A, 0x00, 0x00, 0x5C, 0xEF, 0x6D, 0x6B, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, 0xCE, 0x7B, 0x00, 0x00, 0xBD, 0xF7, 0xEF, 0x7B, + 0x5D, 0xEF, 0x7D, 0xEF, 0xFB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, + 0x9A, 0xD6, 0xFB, 0xDE, 0x38, 0xC6, 0x9A, 0xD6, 0x1C, 0xE7, 0x5D, 0xEF, 0xDB, 0xDE, 0x1C, 0xE7, + 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, + 0x5D, 0xEF, 0x5D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, 0xFB, 0xDE, 0xBA, 0xD6, 0xDB, 0xDE, 0x9A, 0xD6, + 0x96, 0xB5, 0x18, 0xC6, 0xC7, 0x39, 0x75, 0xAD, 0x59, 0xCE, 0xBA, 0xD6, 0xF7, 0xBD, 0x38, 0xC6, + 0x00, 0x00, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x75, 0xAD, 0xD7, 0xBD, 0xE7, 0x39, 0x55, 0xAD, + 0xBA, 0xD6, 0xBA, 0xD6, 0x59, 0xCE, 0x79, 0xCE, 0x79, 0xCE, 0x38, 0xC6, 0x38, 0xC6, 0x55, 0xAD, + 0xF7, 0xBD, 0xF7, 0xBD, 0x75, 0xAD, 0x96, 0xB5, 0xD7, 0xBD, 0x4D, 0x6B, 0x75, 0xAD, 0x45, 0x29, + 0x9A, 0xD6, 0x10, 0x84, 0x79, 0xCE, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, + 0xB6, 0xB5, 0x82, 0x10, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, 0xB2, 0x94, 0x00, 0x00, 0x99, 0xD6, + 0x99, 0xD6, 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xC7, 0x39, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, 0x69, 0x4A, 0xBD, 0xF7, 0x13, 0xA5, 0xFF, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x63, 0xDA, 0xDE, 0xFF, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0x50, 0x8C, 0xBD, 0xF7, 0xEF, 0x7B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x70, 0x8C, 0xFE, 0xFF, 0x91, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x13, 0xA5, 0xFF, 0xFF, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xF6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x7C, 0xEF, 0xFE, 0xFF, 0x1A, 0xE7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0xFF, 0xFF, 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x00, 0x00, 0x58, 0xCE, 0x00, 0x00, 0x61, 0x08, 0x92, 0x94, 0x00, 0x00, 0xCF, 0x7B, + 0x1A, 0xE7, 0x00, 0x00, 0x5C, 0xEF, 0x45, 0x29, 0x00, 0x00, 0x0C, 0x63, 0x00, 0x00, 0x69, 0x4A, + 0x96, 0xB5, 0x18, 0xC6, 0x55, 0xAD, 0xF7, 0xBD, 0x79, 0xCE, 0xDB, 0xDE, 0x38, 0xC6, 0x9A, 0xD6, + 0x14, 0xA5, 0x96, 0xB5, 0xD3, 0x9C, 0x55, 0xAD, 0xD7, 0xBD, 0x38, 0xC6, 0x96, 0xB5, 0xD7, 0xBD, + 0x9D, 0xF7, 0x48, 0x4A, 0xBD, 0xF7, 0x69, 0x4A, 0x00, 0x00, 0x28, 0x42, 0x00, 0x00, 0xE7, 0x39, + 0x9D, 0xF7, 0x28, 0x42, 0x5C, 0xEF, 0x65, 0x29, 0x00, 0x00, 0x08, 0x42, 0x00, 0x00, 0x65, 0x29, + 0x92, 0x94, 0xF3, 0x9C, 0x30, 0x84, 0x71, 0x8C, 0x14, 0xA5, 0xCB, 0x5A, 0xA6, 0x31, 0x00, 0x00, + 0xAE, 0x73, 0x04, 0x21, 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, + 0xDB, 0xDE, 0xFB, 0xDE, 0x9A, 0xD6, 0x9A, 0xD6, 0xBA, 0xD6, 0x9A, 0xD6, 0x59, 0xCE, 0x2C, 0x63, + 0x38, 0xC6, 0x75, 0xAD, 0x10, 0x84, 0x82, 0x10, 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xD3, 0x9C, 0x24, 0x21, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, + 0x00, 0x00, 0xA2, 0x10, 0x4C, 0x6B, 0x1A, 0xE7, 0xB5, 0xB5, 0xDE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x29, 0x00, 0x00, 0x13, 0xA5, 0x37, 0xC6, 0xFE, 0xFF, + 0x0B, 0x63, 0x1B, 0xE7, 0x9D, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xA2, 0x10, 0x74, 0xAD, 0x1B, 0xE7, 0xFF, 0xFF, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x37, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0xF2, 0x9C, 0xB2, 0x94, + 0xFF, 0xFF, 0xBD, 0xF7, 0xFA, 0xDE, 0x8D, 0x73, 0xB2, 0x94, 0x91, 0x94, 0x17, 0xC6, 0xFE, 0xFF, + 0xAE, 0x73, 0x1B, 0xE7, 0xBD, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0x78, 0xCE, 0xEE, 0x7B, + 0x5C, 0xEF, 0x71, 0x8C, 0x8D, 0x73, 0x78, 0xCE, 0x91, 0x94, 0x5B, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, + 0x58, 0xCE, 0x54, 0xAD, 0xB5, 0xB5, 0xBD, 0xF7, 0x1B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9C, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x99, 0xD6, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xDE, 0xFF, 0x8D, 0x73, 0x58, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0x49, 0x4A, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD9, 0xDE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xD2, 0x9C, 0x9D, 0xF7, 0x48, 0x4A, + 0x8D, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x51, 0x8C, 0x49, 0x4A, 0xD3, 0x9C, + 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, 0x65, 0x29, 0xEF, 0x7B, 0x14, 0xA5, 0xB2, 0x94, 0x55, 0xAD, + 0x61, 0x08, 0xB2, 0x94, 0x28, 0x42, 0x34, 0xA5, 0xB6, 0xB5, 0x59, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, + 0x51, 0x8C, 0x55, 0xAD, 0xF3, 0x9C, 0x96, 0xB5, 0xF7, 0xBD, 0x79, 0xCE, 0x18, 0xC6, 0xBA, 0xD6, + 0xBA, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFB, 0xDE, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x34, 0xA5, 0xD7, 0xBD, 0x75, 0xAD, 0x18, 0xC6, 0x59, 0xCE, 0xDB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, + 0xB6, 0xB5, 0x38, 0xC6, 0xF7, 0xBD, 0x79, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, + 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9A, 0xD6, 0x18, 0xC6, 0xBA, 0xD6, 0x59, 0xCE, + 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0x9A, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0xBA, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, + 0xCF, 0x7B, 0x00, 0x00, 0xB2, 0x94, 0x20, 0x00, 0x00, 0x00, 0xDA, 0xDE, 0x00, 0x00, 0x17, 0xC6, + 0x34, 0xA5, 0x41, 0x08, 0x96, 0xB5, 0x61, 0x08, 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0xB6, 0xB5, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x96, 0xB5, 0x61, 0x08, 0x96, 0xB5, 0x61, 0x08, 0x00, 0x00, 0xD6, 0xBD, 0x00, 0x00, 0xF6, 0xBD, + 0x75, 0xAD, 0x41, 0x08, 0x55, 0xAD, 0x41, 0x08, 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0xF6, 0xBD, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x91, 0x94, 0xFE, 0xFF, 0xB5, 0xB5, 0xDD, 0xFF, 0xFE, 0xFF, 0x30, 0x84, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0x30, 0x84, 0xFF, 0xFF, 0xD6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDD, 0xFF, 0xFE, 0xFF, 0x70, 0x8C, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x75, 0xAD, 0xD2, 0x9C, 0xFE, 0xFF, 0xF2, 0x9C, 0xFE, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0xFF, 0xFF, + 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x0F, 0x84, 0x78, 0xCE, 0x7C, 0xEF, 0x6D, 0x6B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xAE, 0x73, 0x00, 0x00, 0x9C, 0xF7, 0x2C, 0x63, 0x00, 0x00, 0x28, 0x42, 0x00, 0x00, 0x20, 0x00, + 0xFF, 0xFF, 0x5C, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, 0x89, 0x52, 0x00, 0x00, 0xFA, 0xDE, 0x65, 0x29, + 0xF3, 0x9C, 0x14, 0xA5, 0x8A, 0x52, 0x92, 0x94, 0x30, 0x84, 0x20, 0x00, 0x8A, 0x52, 0x00, 0x00, + 0x00, 0x00, 0xCB, 0x5A, 0x00, 0x00, 0x20, 0x00, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xB5, 0xB5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x4A, + 0xFE, 0xFF, 0x71, 0x8C, 0xFF, 0xFF, 0x9C, 0xF7, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x00, 0x00, + 0x00, 0x00, 0x74, 0xAD, 0x00, 0x00, 0x1A, 0xE7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x4C, 0x6B, 0xDE, 0xFF, 0x74, 0xAD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFA, 0xDE, 0xFF, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xFF, 0xFF, 0xA6, 0x31, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0x17, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x54, 0xAD, 0xFE, 0xFF, 0x91, 0x94, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x50, 0x8C, 0xDD, 0xFF, 0x74, 0xAD, + 0xB6, 0xB5, 0xFF, 0xFF, 0xB6, 0xB5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD6, 0xBD, 0xFF, 0xFF, 0xF7, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0x99, 0xD6, 0xFF, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9C, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, + 0x3B, 0xE7, 0x00, 0x00, 0x1A, 0xE7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x99, 0xD6, 0x00, 0x00, 0xF7, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB5, 0xB5, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x95, 0xB5, 0x13, 0xA5, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xB6, 0xB5, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0x69, 0x4A, 0xBD, 0xF7, 0x8D, 0x73, 0xFE, 0xFF, + 0x0B, 0x63, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, 0xB2, 0x94, 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0x30, 0x84, 0x91, 0x94, 0xD6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x99, 0xD6, 0x3B, 0xE7, 0x6D, 0x6B, + 0xFE, 0xFF, 0x13, 0xA5, 0xD6, 0xBD, 0xB1, 0x94, 0x54, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xEE, 0x7B, 0xDD, 0xFF, 0x7C, 0xEF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0x50, 0x8C, 0x0F, 0x84, 0xF6, 0xBD, 0x75, 0xAD, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0x54, 0xAD, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xAD, 0x73, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, + 0x00, 0x00, 0xEB, 0x5A, 0x41, 0x08, 0x10, 0x84, 0xF3, 0x9C, 0x96, 0xB5, 0x34, 0xA5, 0xD7, 0xBD, + 0x04, 0x21, 0xB2, 0x94, 0x28, 0x42, 0xF3, 0x9C, 0x55, 0xAD, 0xF7, 0xBD, 0x96, 0xB5, 0x38, 0xC6, + 0xFF, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, 0x13, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x08, + 0xDE, 0xFF, 0x0B, 0x63, 0x1B, 0xE7, 0x00, 0x00, 0x00, 0x00, 0x45, 0x29, 0x00, 0x00, 0x69, 0x4A, + 0x4D, 0x6B, 0x14, 0xA5, 0x51, 0x8C, 0x55, 0xAD, 0xB6, 0xB5, 0x59, 0xCE, 0xF7, 0xBD, 0x79, 0xCE, + 0xD3, 0x9C, 0x75, 0xAD, 0x14, 0xA5, 0xB6, 0xB5, 0x18, 0xC6, 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, + 0x18, 0xC6, 0xBA, 0xD6, 0x59, 0xCE, 0xDB, 0xDE, 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, + 0x79, 0xCE, 0xFB, 0xDE, 0xBA, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDB, 0xDE, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0xBA, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xBA, 0xD6, 0x3C, 0xE7, 0xBA, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, + 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, + 0x55, 0xAD, 0x41, 0x08, 0x34, 0xA5, 0x20, 0x00, 0x00, 0x00, 0x17, 0xC6, 0x00, 0x00, 0x17, 0xC6, + 0x34, 0xA5, 0x20, 0x00, 0x55, 0xAD, 0x41, 0x08, 0x00, 0x00, 0x17, 0xC6, 0x00, 0x00, 0xF6, 0xBD, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x96, 0xB5, 0x41, 0x08, 0xD7, 0xBD, 0x82, 0x10, 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0x74, 0xAD, + 0x18, 0xC6, 0xE3, 0x18, 0x59, 0xCE, 0x65, 0x29, 0x00, 0x00, 0xB2, 0x94, 0x00, 0x00, 0x30, 0x84, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x0F, 0x84, 0xDE, 0xFF, 0x54, 0xAD, 0x74, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xDE, 0xFF, 0xCE, 0x7B, 0xFF, 0xFF, 0x1A, 0xE7, 0xFA, 0xDE, 0xFF, 0xFF, 0xCE, 0x7B, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x74, 0xAD, 0x95, 0xB5, 0xDD, 0xFF, 0xAE, 0x73, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0xFF, 0xFF, 0x13, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x3B, 0xE7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x50, 0x8C, 0xFE, 0xFF, 0xB1, 0x94, 0x78, 0xCE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x58, 0xCE, 0xFF, 0xFF, + 0x89, 0x52, 0x00, 0x00, 0x37, 0xC6, 0x00, 0x00, 0xCA, 0x5A, 0xBD, 0xF7, 0x00, 0x00, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xAE, 0x73, 0xFF, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x30, 0x84, 0x00, 0x00, 0xFA, 0xDE, 0x00, 0x00, + 0x7C, 0xEF, 0xFE, 0xFF, 0x34, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x65, 0x29, 0x5C, 0xEF, 0x00, 0x00, 0x33, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFD, 0xF7, 0xFD, 0xFF, 0xFD, 0xFF, 0xFD, 0xF7, 0xFD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x9C, 0xEF, 0x77, 0xCE, + 0xFD, 0xFF, 0x56, 0xC6, 0x77, 0xC6, 0x00, 0x00, 0xC6, 0x39, 0x00, 0x00, 0xE8, 0x5A, 0x52, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, 0xFF, 0xFF, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x50, 0x8C, 0xFE, 0xFF, 0x70, 0x8C, + 0xFF, 0xFF, 0xFE, 0xFF, 0xD5, 0xBD, 0xD5, 0xBD, 0xFE, 0xFF, 0xFE, 0xFF, 0x36, 0xC6, 0x19, 0xE7, + 0x00, 0x00, 0x00, 0x00, 0x14, 0xDF, 0x14, 0xDF, 0x00, 0x00, 0x00, 0x00, 0xB2, 0xD6, 0xAF, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xBC, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x48, 0x4A, 0x11, 0xA5, 0xCA, 0x73, 0x00, 0x00, 0x3A, 0xE7, 0xFE, 0xFF, 0x00, 0x00, 0x93, 0xB5, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x31, 0xB9, 0xD6, 0xFF, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, + 0x00, 0x00, 0x4C, 0x6B, 0x00, 0x00, 0x13, 0xA5, 0xDE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, + 0x58, 0xCE, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xDC, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x17, 0xC6, 0xDD, 0xFF, 0x58, 0xCE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xDD, 0xFF, 0xFF, 0xFF, 0x13, 0xA5, 0xCE, 0x7B, 0xDA, 0xDE, 0xB5, 0xB5, 0xFF, 0xFF, + 0x99, 0xD6, 0x30, 0x84, 0xCE, 0x7B, 0x5B, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x58, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x5C, 0xEF, 0xFF, 0xFF, 0xF6, 0xBD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xAE, 0x73, 0x1B, 0xE7, 0x00, 0x00, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0x13, 0xA5, 0x00, 0x00, 0xC7, 0x39, 0x00, 0x00, + 0xD6, 0xBD, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, 0x00, 0x00, 0xCF, 0x7B, 0xC3, 0x18, 0xB2, 0x94, + 0xE3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x42, 0xF3, 0x9C, 0x8E, 0x73, 0x34, 0xA5, + 0x34, 0xA5, 0xD7, 0xBD, 0x75, 0xAD, 0x18, 0xC6, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, + 0x96, 0xB5, 0x38, 0xC6, 0xD7, 0xBD, 0x79, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, 0x5D, 0xEF, + 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, 0x28, 0x42, 0xB2, 0x94, 0x75, 0xAD, 0xF3, 0x9C, 0x96, 0xB5, + 0x20, 0x00, 0xEF, 0x7B, 0x45, 0x29, 0xD3, 0x9C, 0x34, 0xA5, 0xD7, 0xBD, 0x75, 0xAD, 0x18, 0xC6, + 0xF7, 0xBD, 0x9A, 0xD6, 0x38, 0xC6, 0xBA, 0xD6, 0xFB, 0xDE, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, + 0x59, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, + 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0xFB, 0xDE, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, + 0x59, 0xCE, 0x08, 0x42, 0x79, 0xCE, 0x0C, 0x63, 0x00, 0x00, 0x0B, 0x63, 0x00, 0x00, 0xC6, 0x39, + 0x9A, 0xD6, 0x10, 0x84, 0x9A, 0xD6, 0x34, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0xDD, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0xFF, 0xFF, 0xB5, 0xB5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, 0x79, 0xCE, 0x24, 0x21, 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, 0xDB, 0xDE, 0x14, 0xA5, 0x20, 0x00, 0x38, 0xC6, 0x49, 0x4A, + 0xAE, 0x73, 0xFE, 0xFF, 0x00, 0x00, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x71, 0x8C, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFE, 0xFF, 0x37, 0xC6, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x5C, 0xEF, 0xAE, 0x73, 0xFF, 0xFF, 0x95, 0xB5, 0xBD, 0xF7, 0xFE, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, + 0xFE, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x13, 0xA5, 0xBD, 0xF7, 0x7C, 0xEF, 0x9D, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x91, 0x94, 0xFE, 0xFF, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xF2, 0x9C, 0x99, 0xD6, 0xBC, 0xEF, 0xFE, 0xFF, 0xFD, 0xF7, 0xFD, 0xF7, 0xFC, 0xF7, + 0xFE, 0xFF, 0xFD, 0xF7, 0xFD, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFB, 0xF7, 0xFB, 0xF7, 0xFB, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFC, 0xF7, 0xFD, 0xFF, 0xFC, 0xF7, + 0xFC, 0xF7, 0xFB, 0xF7, 0xFC, 0xF7, 0xFB, 0xF7, 0xFB, 0xF7, 0xB3, 0xAD, 0x38, 0xD7, 0xC6, 0x39, + 0xFB, 0xF7, 0xFB, 0xF7, 0xFB, 0xF7, 0x59, 0xDF, 0x8F, 0x8C, 0x31, 0x95, 0x48, 0x42, 0x99, 0xDF, + 0xFD, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFB, 0xF7, 0xFC, 0xF7, 0xDB, 0xEF, 0xFA, 0xEF, 0x37, 0xD7, + 0xFB, 0xEF, 0x11, 0x9D, 0xD0, 0x94, 0x2B, 0x5B, 0x31, 0x9D, 0x16, 0xCF, 0x98, 0xDF, 0xF5, 0xCE, + 0x2A, 0x5B, 0x25, 0x42, 0x00, 0x00, 0x6E, 0xA5, 0x75, 0xE7, 0xF6, 0xFF, 0xF5, 0xF7, 0xF3, 0xF7, + 0x00, 0x00, 0x0F, 0xB6, 0x00, 0x00, 0x2F, 0xB6, 0xF3, 0xF7, 0xF2, 0xF7, 0xF3, 0xEF, 0xF0, 0xF7, + 0xEA, 0x52, 0xB9, 0xDF, 0x17, 0xCF, 0xFA, 0xEF, 0xFA, 0xEF, 0x15, 0xCF, 0xFA, 0xE7, 0x97, 0xD7, + 0xFB, 0xEF, 0x54, 0xB6, 0x37, 0xCF, 0x85, 0x29, 0x92, 0x9D, 0xF8, 0xE7, 0xB5, 0xBE, 0xF9, 0xE7, + 0x00, 0x00, 0xAD, 0xA5, 0xC5, 0x31, 0x09, 0x74, 0xF2, 0xEF, 0xF0, 0xEF, 0xF1, 0xE7, 0xF0, 0xEF, + 0xAD, 0x84, 0x00, 0x00, 0xF3, 0xBE, 0x00, 0x00, 0x30, 0xCF, 0xF0, 0xEF, 0x69, 0x7C, 0xF0, 0xE7, + 0xF5, 0xF7, 0xF4, 0xFF, 0xF2, 0xF7, 0x70, 0xE7, 0xF4, 0xFF, 0xF5, 0xFF, 0x0D, 0xBE, 0x0D, 0xBE, + 0x0E, 0xD7, 0x03, 0x3A, 0xE9, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0xC6, 0xEA, 0xD6, + 0xF5, 0xFF, 0xF3, 0xDE, 0x10, 0xDF, 0xF3, 0xFF, 0xEA, 0x7B, 0x00, 0x00, 0xF4, 0xF7, 0x8F, 0xAD, + 0x00, 0x00, 0x89, 0x8C, 0xC7, 0x94, 0x00, 0x00, 0x91, 0xEF, 0xF5, 0xFF, 0x06, 0x5B, 0x71, 0xE7, + 0x68, 0x84, 0xC1, 0x31, 0x89, 0xA5, 0x00, 0x00, 0xCA, 0xEF, 0xEA, 0xFF, 0xE8, 0xD6, 0xE8, 0xF7, + 0x0C, 0xCF, 0x00, 0x00, 0xEF, 0xE7, 0xE8, 0x8C, 0xA5, 0x8C, 0xE9, 0xF7, 0x00, 0x00, 0xC7, 0xAD, + 0xEB, 0xF7, 0x29, 0xBE, 0xE8, 0xF7, 0xEB, 0xFF, 0x00, 0x00, 0xA7, 0x6B, 0xC8, 0xB5, 0x00, 0x00, + 0xE8, 0xF7, 0x69, 0xE7, 0xEA, 0xF7, 0x48, 0xBE, 0xEC, 0xF7, 0xE6, 0x7B, 0x2B, 0xDF, 0xEC, 0xD6, + 0xED, 0x7B, 0x7B, 0xEF, 0x00, 0x00, 0xEA, 0x5A, 0xFE, 0xFF, 0xFE, 0xFF, 0x7B, 0xEF, 0xFE, 0xFF, + 0x51, 0xC6, 0x00, 0x00, 0xF5, 0xFF, 0x51, 0xC6, 0x6C, 0x6B, 0xBC, 0xF7, 0x00, 0x00, 0x12, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD2, 0xEF, 0xF6, 0xFF, 0x6C, 0xA5, 0xF5, 0xFF, 0x6F, 0xAD, 0x00, 0x00, 0xD6, 0xF7, 0xC7, 0x52, + 0x00, 0x00, 0x52, 0xDF, 0x00, 0x00, 0x6D, 0xA5, 0xF7, 0xFF, 0x12, 0xBE, 0xF6, 0xFF, 0x77, 0xE7, + 0x3A, 0xE7, 0xFF, 0xFF, 0x33, 0xA5, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xEB, 0x5A, 0xDD, 0xFF, 0xC9, 0x52, 0x9C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x5C, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xF6, 0xBD, + 0xFF, 0xFF, 0x54, 0xAD, 0x3B, 0xE7, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x21, + 0x30, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x73, 0xC7, 0x39, 0xD3, 0x9C, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x5C, 0xEF, 0xFA, 0xDE, 0xA2, 0x10, 0x89, 0x52, 0x00, 0x00, + 0x9C, 0xF7, 0x4C, 0x6B, 0x4C, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x39, + 0x00, 0x00, 0xA2, 0x10, 0x20, 0x00, 0x6D, 0x6B, 0x71, 0x8C, 0x34, 0xA5, 0x14, 0xA5, 0x96, 0xB5, + 0x8A, 0x52, 0xF3, 0x9C, 0xD3, 0x9C, 0x55, 0xAD, 0x75, 0xAD, 0xF7, 0xBD, 0xD7, 0xBD, 0x59, 0xCE, + 0x4D, 0x6B, 0x34, 0xA5, 0xD3, 0x9C, 0x75, 0xAD, 0xB6, 0xB5, 0x59, 0xCE, 0xF7, 0xBD, 0x9A, 0xD6, + 0x34, 0xA5, 0xB6, 0xB5, 0x75, 0xAD, 0xF7, 0xBD, 0x38, 0xC6, 0xBA, 0xD6, 0x79, 0xCE, 0xFB, 0xDE, + 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0xD7, 0xBD, 0x59, 0xCE, 0x18, 0xC6, 0x9A, 0xD6, 0xBA, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x5D, 0xEF, + 0x79, 0xCE, 0xDB, 0xDE, 0xBA, 0xD6, 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0x1C, 0xE7, 0x79, 0xCE, 0x55, 0xAD, 0xBA, 0xD6, 0x59, 0xCE, + 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xFB, 0xDE, 0x9A, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, + 0x82, 0x10, 0x00, 0x00, 0x10, 0x84, 0x20, 0x00, 0x03, 0x21, 0xD9, 0xDE, 0x00, 0x00, 0x85, 0x31, + 0x18, 0xC6, 0x6D, 0x6B, 0x79, 0xCE, 0xF7, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x73, 0x20, 0x00, + 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x59, 0xCE, 0x1C, 0xE7, 0xBA, 0xD6, 0xF7, 0xBD, 0x30, 0x84, 0x59, 0xCE, 0xF7, 0xBD, + 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xBA, 0xD6, 0x59, 0xCE, 0x1C, 0xE7, 0xDB, 0xDE, + 0xFF, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xF6, 0xBD, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0x5C, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xC3, 0x18, 0x00, 0x00, 0x34, 0xA5, 0x08, 0x42, 0x00, 0x00, 0x86, 0x31, 0x00, 0x00, 0x00, 0x00, + 0xF7, 0xBD, 0xB6, 0xB5, 0x79, 0xCE, 0x38, 0xC6, 0xEF, 0x7B, 0x04, 0x21, 0xD7, 0xBD, 0x75, 0xAD, + 0x95, 0xB5, 0x9D, 0xF7, 0x00, 0x00, 0x89, 0x52, 0xFF, 0xFF, 0xFE, 0xFF, 0xD6, 0xBD, 0x9C, 0xF7, + 0x00, 0x00, 0x00, 0x00, 0x4D, 0x6B, 0xE3, 0x18, 0x00, 0x00, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x33, 0xA5, 0x1A, 0xE7, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0x8D, 0x73, 0x95, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFA, 0xDE, 0xDD, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0x37, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x1B, 0xE7, + 0xBD, 0xF7, 0x37, 0xC6, 0xEB, 0x5A, 0x00, 0x00, 0xAD, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0xEF, 0x7B, 0x9D, 0xF7, 0xFA, 0xDE, 0x28, 0x42, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x8D, 0x73, 0x00, 0x00, 0x00, 0x00, 0x54, 0xAD, 0x58, 0xCE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFB, 0xF7, 0xFD, 0xFF, 0xFB, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, 0xFF, 0xFC, 0xF7, 0xFC, 0xFF, 0xFC, 0xF7, + 0xFB, 0xF7, 0xF4, 0xB5, 0xFB, 0xF7, 0x2E, 0x7C, 0x4E, 0x7C, 0xFA, 0xE7, 0x55, 0xB6, 0x14, 0xB6, + 0xDB, 0xEF, 0x2B, 0x5B, 0xBA, 0xE7, 0x4B, 0x63, 0xB6, 0xC6, 0x0A, 0x5B, 0xB3, 0xAD, 0xCC, 0x6B, + 0x17, 0xC6, 0x3B, 0xE7, 0x00, 0x00, 0xEB, 0x5A, 0xFD, 0xFF, 0xFC, 0xF7, 0xDC, 0xF7, 0xFC, 0xFF, + 0x00, 0x00, 0xB1, 0x94, 0x3B, 0xE7, 0xFE, 0xFF, 0xFD, 0xFF, 0xFC, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, + 0x59, 0xDF, 0x2B, 0x63, 0x59, 0xE7, 0xED, 0x73, 0x90, 0x8C, 0x92, 0xA5, 0xCD, 0x73, 0x11, 0x95, + 0xFC, 0xF7, 0x9A, 0xE7, 0xFC, 0xF7, 0xFC, 0xF7, 0xED, 0x73, 0x89, 0x4A, 0x18, 0xD7, 0x28, 0x42, + 0x4B, 0x63, 0xD2, 0xA5, 0x8B, 0x63, 0xF9, 0xE7, 0xF9, 0xE7, 0xF9, 0xDF, 0x77, 0xCF, 0xF5, 0xBE, + 0xF6, 0xC6, 0x78, 0xD7, 0x99, 0xDF, 0x0A, 0x5B, 0x68, 0x42, 0xB2, 0x9D, 0x71, 0x95, 0xF9, 0xDF, + 0xF7, 0xDF, 0x0D, 0x8D, 0xF8, 0xD7, 0xB5, 0xCF, 0x00, 0x00, 0xCC, 0xA5, 0xA9, 0x63, 0x00, 0x00, + 0xF8, 0xDF, 0xF8, 0xDF, 0xD8, 0xD7, 0x33, 0xA6, 0x94, 0xCF, 0x48, 0x5B, 0xD6, 0xCF, 0xB5, 0xCF, + 0x31, 0x95, 0x6E, 0x7C, 0xA9, 0x52, 0x98, 0xD7, 0xF9, 0xE7, 0xD8, 0xD7, 0xD9, 0xDF, 0xAC, 0x63, + 0x51, 0x9D, 0xFA, 0xE7, 0x18, 0xD7, 0x72, 0x9D, 0xED, 0x73, 0x8E, 0x84, 0xCC, 0x6B, 0xFA, 0xE7, + 0x2D, 0x74, 0xAB, 0x63, 0x2D, 0x74, 0xD8, 0xD7, 0xB7, 0xCF, 0xF7, 0xD7, 0xF9, 0xDF, 0xD8, 0xD7, + 0xF9, 0xDF, 0xF9, 0xE7, 0xFA, 0xE7, 0xB5, 0xBE, 0x97, 0xCF, 0xCC, 0x6B, 0x68, 0x42, 0xCF, 0x8C, + 0xF0, 0xE7, 0xCE, 0xDF, 0x0C, 0xAE, 0xF0, 0xE7, 0x87, 0x84, 0x00, 0x00, 0xEF, 0xE7, 0x4B, 0xB6, + 0x00, 0x00, 0x2B, 0x95, 0x4B, 0x74, 0x00, 0x00, 0xB0, 0xDF, 0xF0, 0xEF, 0xC5, 0x4A, 0x4D, 0xB6, + 0xA6, 0x8C, 0x86, 0x8C, 0x47, 0x7C, 0xC8, 0x8C, 0xEA, 0xB5, 0xEF, 0xF7, 0x8E, 0xDF, 0xF1, 0xF7, + 0xF0, 0xEF, 0xF0, 0xEF, 0xB1, 0xDF, 0xF2, 0xEF, 0xF1, 0xEF, 0xF2, 0xEF, 0xF3, 0xEF, 0xF4, 0xEF, + 0xF6, 0xD7, 0x30, 0xA6, 0xD1, 0x9D, 0xB6, 0xD7, 0x46, 0x3A, 0x00, 0x00, 0xB6, 0xD7, 0x31, 0xAE, + 0xEC, 0x6B, 0xD8, 0xD7, 0xF9, 0xDF, 0xF9, 0xE7, 0xF9, 0xE7, 0xF5, 0xC6, 0x13, 0xAE, 0x66, 0x29, + 0x64, 0x42, 0xEB, 0x8C, 0xCA, 0x6B, 0x00, 0x00, 0xEF, 0xAD, 0x2D, 0x95, 0x00, 0x00, 0x00, 0x00, + 0x56, 0xCF, 0x77, 0xD7, 0x17, 0xCF, 0xFA, 0xEF, 0x16, 0xCF, 0x77, 0xD7, 0xFA, 0xEF, 0x14, 0xAE, + 0x46, 0x63, 0xA7, 0x52, 0x8C, 0xA5, 0x00, 0x00, 0xD5, 0xEF, 0xF8, 0xF7, 0x14, 0xDF, 0xF9, 0xFF, + 0x4F, 0xBE, 0x00, 0x00, 0x8E, 0xA5, 0x00, 0x00, 0xB3, 0xCE, 0xFA, 0xFF, 0xF5, 0xD6, 0xFB, 0xF7, + 0x0D, 0x7C, 0x1A, 0xDF, 0x10, 0x9D, 0x3A, 0xE7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD4, 0xB5, 0x9C, 0xEF, 0x97, 0xC6, 0xDD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x4A, 0x63, 0xCC, 0x73, 0x58, 0xD7, 0xD9, 0xEF, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, + 0xFA, 0xEF, 0xFC, 0xEF, 0x59, 0xD7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, + 0x9B, 0xEF, 0xFD, 0xFF, 0xFD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xB2, 0x94, 0xBD, 0xF7, 0xA6, 0x31, + 0xFD, 0xF7, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x89, 0x52, 0x50, 0x8C, 0x00, 0x00, 0x00, 0x00, 0x95, 0xB5, 0xB9, 0xD6, 0x00, 0x00, 0x00, 0x00, + 0xD2, 0x9C, 0x6D, 0x6B, 0xFF, 0xFF, 0xFE, 0xFF, 0x86, 0x31, 0x00, 0x00, 0x7C, 0xEF, 0x99, 0xD6, + 0x9C, 0xF7, 0x9D, 0xF7, 0x07, 0x42, 0x28, 0x42, 0x78, 0xCE, 0x50, 0x8C, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x54, 0xAD, 0x8D, 0x73, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0x5B, 0xEF, 0x95, 0xB5, 0xBD, 0xF7, 0xF6, 0xBD, 0xAA, 0x52, 0x00, 0x00, + 0xFE, 0xFF, 0xFF, 0xFF, 0xBD, 0xF7, 0x54, 0xAD, 0xDA, 0xDE, 0x89, 0x52, 0x00, 0x00, 0x00, 0x00, + 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x21, 0x6D, 0x6B, + 0x03, 0x21, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x28, 0x42, + 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, 0x4D, 0x6B, 0x00, 0x00, 0x61, 0x08, + 0xA2, 0x10, 0x69, 0x4A, 0x8E, 0x73, 0x10, 0x84, 0x30, 0x84, 0xB2, 0x94, 0x71, 0x8C, 0xF3, 0x9C, + 0xCF, 0x7B, 0x10, 0x84, 0x86, 0x31, 0x2C, 0x63, 0x92, 0x94, 0xF3, 0x9C, 0x92, 0x94, 0x14, 0xA5, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xE7, 0x39, 0xC7, 0x39, 0xD3, 0x9C, 0xD3, 0x9C, 0x34, 0xA5, + 0x8A, 0x52, 0xD3, 0x9C, 0xD3, 0x9C, 0x34, 0xA5, 0x34, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, 0x18, 0xC6, + 0x34, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, 0x38, 0xC6, 0x38, 0xC6, 0xBA, 0xD6, 0x9A, 0xD6, 0xFB, 0xDE, + 0x18, 0xC6, 0x9A, 0xD6, 0x79, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, 0x3C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, + 0x14, 0xA5, 0x96, 0xB5, 0x55, 0xAD, 0xD7, 0xBD, 0xF7, 0xBD, 0x59, 0xCE, 0x38, 0xC6, 0xBA, 0xD6, + 0x75, 0xAD, 0xD7, 0xBD, 0x75, 0xAD, 0xF7, 0xBD, 0x59, 0xCE, 0xBA, 0xD6, 0x59, 0xCE, 0xBA, 0xD6, + 0xBA, 0xD6, 0x1C, 0xE7, 0xFB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFB, 0xDE, 0x3C, 0xE7, 0xFB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, + 0xFB, 0xDE, 0x5D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x7D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDB, 0xDE, 0x9A, 0xD6, 0x3C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x7D, 0xEF, 0xFB, 0xDE, 0xBA, 0xD6, 0x5D, 0xEF, 0x1C, 0xE7, + 0x96, 0xB5, 0x34, 0xA5, 0x18, 0xC6, 0xB6, 0xB5, 0x6D, 0x6B, 0x45, 0x29, 0x55, 0xAD, 0xF3, 0x9C, + 0x79, 0xCE, 0x18, 0xC6, 0xBA, 0xD6, 0x59, 0xCE, 0xB6, 0xB5, 0x34, 0xA5, 0xF7, 0xBD, 0x75, 0xAD, + 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, + 0xBE, 0xF7, 0x9E, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x3C, 0xE7, 0xFB, 0xDE, 0x1C, 0xE7, 0xDB, 0xDE, + 0xBA, 0xD6, 0x79, 0xCE, 0xDB, 0xDE, 0x79, 0xCE, 0xF7, 0xBD, 0x34, 0xA5, 0x34, 0xA5, 0x04, 0x21, + 0x9A, 0xD6, 0x14, 0xA5, 0x14, 0xA5, 0x82, 0x10, 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0xCF, 0x7B, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x20, 0x00, + 0xD3, 0x9C, 0x51, 0x8C, 0x14, 0xA5, 0x49, 0x4A, 0xCB, 0x5A, 0x41, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x8C, 0xA6, 0x31, 0xB6, 0xB5, 0x5C, 0xEF, 0xFF, 0xFF, + 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x29, 0x4C, 0x6B, 0x1B, 0xE7, + 0x00, 0x00, 0x71, 0x8C, 0x54, 0xAD, 0xFE, 0xFF, 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x17, 0xC6, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xEB, 0x5A, 0x37, 0xC6, 0xEB, 0x5A, 0xB5, 0xB5, 0xDD, 0xFF, 0xFF, 0xFF, + 0xBD, 0xF7, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, + 0xFF, 0xFF, 0xDD, 0xFF, 0x99, 0xD6, 0xAE, 0x73, 0xF6, 0xBD, 0xD2, 0x9C, 0x74, 0xAD, 0xBD, 0xF7, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFC, 0xFF, 0xFC, 0xF7, 0xFD, 0xFF, 0xFC, 0xFF, 0xFB, 0xF7, 0x38, 0xDF, 0xFC, 0xF7, 0xFC, 0xFF, + 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFC, 0xFF, 0xFC, 0xF7, 0xFD, 0xFF, 0xFC, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFA, 0xDE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDD, 0xFF, 0x50, 0x8C, 0xB9, 0xD6, 0x00, 0x00, + 0xD7, 0xCE, 0x27, 0x42, 0x96, 0xC6, 0xF1, 0x94, 0x79, 0xDF, 0x58, 0xD7, 0xAF, 0x8C, 0x68, 0x4A, + 0xFC, 0xFF, 0xB7, 0xCE, 0xFC, 0xF7, 0xFC, 0xFF, 0x11, 0x95, 0x76, 0xBE, 0x79, 0xE7, 0x0B, 0x5B, + 0x8F, 0x84, 0x07, 0x3A, 0x52, 0x9D, 0xB9, 0xDF, 0x54, 0xB6, 0xFA, 0xE7, 0xFA, 0xE7, 0x34, 0xB6, + 0x96, 0xC6, 0x52, 0x9D, 0xCD, 0x73, 0x11, 0x9D, 0xC9, 0x52, 0x6B, 0x63, 0xB7, 0xCE, 0xBA, 0xE7, + 0xFC, 0xFF, 0xFC, 0xFF, 0xFD, 0xFF, 0xFD, 0xFF, 0xFC, 0xF7, 0x59, 0xE7, 0xFC, 0xFF, 0xDB, 0xF7, + 0x0F, 0x84, 0xBD, 0xF7, 0x00, 0x00, 0x1B, 0xE7, 0xFE, 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x6F, 0x84, 0x4F, 0x84, 0x15, 0xBE, 0x15, 0xBE, 0x0E, 0x7C, 0xCA, 0x52, 0x76, 0xCE, 0xF8, 0xD6, + 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD9, 0xDF, 0x10, 0x8D, 0x88, 0x4A, 0x0D, 0x7C, 0x27, 0x42, 0xF6, 0xC6, 0x78, 0xDF, 0xFB, 0xEF, + 0x96, 0xC6, 0xFB, 0xEF, 0x59, 0xDF, 0xD3, 0xAD, 0xFA, 0xE7, 0x34, 0xB6, 0x0A, 0x5B, 0x2B, 0x5B, + 0xFA, 0xEF, 0xFA, 0xE7, 0x99, 0xDF, 0xED, 0x73, 0xF0, 0x94, 0xCA, 0x52, 0x8C, 0x6B, 0x9A, 0xE7, + 0x27, 0x42, 0xD0, 0x94, 0x96, 0xC6, 0xFC, 0xF7, 0xDB, 0xEF, 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, + 0x68, 0x4A, 0x2E, 0x7C, 0x9A, 0xEF, 0xFC, 0xF7, 0x76, 0xC6, 0xDB, 0xEF, 0xFC, 0xFF, 0xFD, 0xF7, + 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x7A, 0xDF, 0xFC, 0xF7, 0xFC, 0xF7, 0xFC, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xFF, + 0xFC, 0xF7, 0xFD, 0xF7, 0xFD, 0xF7, 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, + 0xFE, 0xFF, 0x16, 0xBE, 0xFE, 0xFF, 0x0F, 0x84, 0xAA, 0x52, 0x78, 0xCE, 0x00, 0x00, 0xA2, 0x10, + 0xFF, 0xFF, 0xDA, 0xDE, 0xFE, 0xFF, 0xFF, 0xFF, 0x24, 0x21, 0x00, 0x00, 0x78, 0xCE, 0x00, 0x00, + 0xFF, 0xFF, 0xFE, 0xFF, 0xDA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0x9C, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0x48, 0x4A, 0x5C, 0xEF, 0x00, 0x00, 0xCE, 0x7B, 0xFF, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x5B, 0xEF, 0x17, 0xC6, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xD2, 0x9C, 0xFF, 0xFF, 0xFE, 0xFF, 0x30, 0x84, 0xD2, 0x9C, 0x9D, 0xF7, 0xDA, 0xDE, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0x1B, 0xE7, 0xD6, 0xBD, 0x71, 0x8C, 0xDE, 0xFF, 0xFF, 0xFF, 0x0F, 0x84, 0x33, 0xA5, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x9C, 0xF7, 0x78, 0xCE, 0xFE, 0xFF, 0xFF, 0xFF, + 0x50, 0x8C, 0xE7, 0x39, 0xFE, 0xFF, 0x9C, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x58, 0xCE, 0x50, 0x8C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x65, 0x29, 0x00, 0x00, 0xC3, 0x18, 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, + 0x7C, 0xEF, 0xD6, 0xBD, 0xFE, 0xFF, 0xFF, 0xFF, 0x4C, 0x6B, 0x00, 0x00, 0xDE, 0xFF, 0x99, 0xD6, + 0xFF, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xD2, 0x9C, 0xCE, 0x7B, 0xFF, 0xFF, 0xBD, 0xF7, 0x33, 0xA5, 0xFA, 0xDE, 0x58, 0xCE, 0x50, 0x8C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0x50, 0x8C, 0xDA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xD3, 0x9C, 0x96, 0xB5, 0x61, 0x08, 0x8A, 0x52, 0xF7, 0xBD, 0x59, 0xCE, 0x34, 0xA5, 0x18, 0xC6, + 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, 0x82, 0x10, 0x0C, 0x63, 0x00, 0x00, 0x00, 0x00, + 0xBA, 0xD6, 0xFB, 0xDE, 0x59, 0xCE, 0xBA, 0xD6, 0x3C, 0xE7, 0x5D, 0xEF, 0xFB, 0xDE, 0x3C, 0xE7, + 0xB6, 0xB5, 0x38, 0xC6, 0x24, 0x21, 0x92, 0x94, 0x79, 0xCE, 0xDB, 0xDE, 0x18, 0xC6, 0x79, 0xCE, + 0xFE, 0xFF, 0x99, 0xD6, 0xFE, 0xFF, 0xFF, 0xFF, 0x2C, 0x63, 0x00, 0x00, 0xDD, 0xFF, 0x95, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x63, 0xF7, 0xBD, 0x00, 0x00, 0x28, 0x42, + 0xDA, 0xDE, 0xAA, 0x52, 0xFF, 0xFF, 0x7C, 0xEF, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, + 0x9E, 0xF7, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x5D, 0xEF, 0xBA, 0xD6, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0x38, 0xC6, 0x9A, 0xD6, 0xB6, 0xB5, 0x38, 0xC6, 0xFB, 0xDE, 0x3C, 0xE7, 0x9A, 0xD6, 0xFB, 0xDE, + 0xA6, 0x31, 0x96, 0xB5, 0x00, 0x00, 0xA6, 0x31, 0x18, 0xC6, 0x9A, 0xD6, 0x96, 0xB5, 0x38, 0xC6, + 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, + 0xDB, 0xDE, 0x3C, 0xE7, 0x9A, 0xD6, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0x7D, 0xEF, 0x1C, 0xE7, 0x3C, 0xE7, 0xFB, 0xDE, + 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0xBA, 0xD6, 0xFB, 0xDE, 0x79, 0xCE, + 0x7D, 0xEF, 0x3C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, 0xDB, 0xDE, 0x96, 0xB5, 0x79, 0xCE, 0x45, 0x29, + 0x1C, 0xE7, 0xDB, 0xDE, 0xFB, 0xDE, 0xB6, 0xB5, 0x2C, 0x63, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, + 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0xD6, 0xBD, 0xFF, 0xFF, + 0x00, 0x00, 0x54, 0xAD, 0x8D, 0x73, 0xDE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBA, 0xD6, 0xCB, 0x5A, 0xD7, 0xBD, 0x61, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, + 0x4D, 0x6B, 0x00, 0x00, 0x04, 0x21, 0x00, 0x00, 0x00, 0x00, 0xB9, 0xD6, 0x6D, 0x6B, 0xFE, 0xFF, + 0xB9, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x5B, 0xEF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0x7C, 0xEF, 0x8D, 0x73, 0xCE, 0x7B, 0x99, 0xD6, + 0xFE, 0xFF, 0x91, 0x94, 0xB5, 0xB5, 0xF3, 0x9C, 0xF6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9C, 0xF7, 0xDD, 0xFF, 0x13, 0xA5, 0x0F, 0x84, 0x95, 0xB5, + 0x5B, 0xEF, 0x8D, 0x73, 0x6D, 0x6B, 0xD9, 0xDE, 0x78, 0xCE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x50, 0x8C, 0x3B, 0xE7, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x54, 0xAD, 0x00, 0x00, 0x8D, 0x73, 0x00, 0x00, + 0xFE, 0xFF, 0x7C, 0xEF, 0xFF, 0xFF, 0x1A, 0xE7, 0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, 0x17, 0xC6, 0x00, 0x00, 0xC3, 0x18, 0x00, 0x00, 0x48, 0x4A, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, 0x00, 0x00, 0x89, 0x52, 0x00, 0x00, 0xCA, 0x5A, + 0x89, 0x52, 0xBD, 0xF7, 0x91, 0x94, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xF6, 0xBD, 0xFF, 0xFF, 0xDA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0xFF, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0xBD, 0xF7, 0xFE, 0xFF, 0x74, 0xAD, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xB9, 0xD6, 0x13, 0xA5, 0xFF, 0xFF, 0xB5, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0x17, 0xC6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xB2, 0x94, 0x3B, 0xE7, 0x5B, 0xEF, 0xB2, 0x94, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x95, 0xB5, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x50, 0x8C, 0x00, 0x00, 0x34, 0xA5, 0xFE, 0xFF, 0x00, 0x00, 0x99, 0xD6, + 0x7C, 0xEF, 0x69, 0x4A, 0xFF, 0xFF, 0x78, 0xCE, 0x00, 0x00, 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF2, 0x9C, 0x00, 0x00, 0x9C, 0xF7, 0x69, 0x4A, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x37, 0xC6, 0xFE, 0xFF, 0xDE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9D, 0xF7, 0xFE, 0xFF, 0xD2, 0x9C, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xB9, 0xD6, 0x00, 0x00, 0x8D, 0x73, 0xFF, 0xFF, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x6D, 0x6B, 0x00, 0x00, 0x37, 0xC6, 0xFF, 0xFF, 0x2B, 0x63, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFA, 0xDE, 0x50, 0x8C, 0xFF, 0xFF, 0xFE, 0xFF, 0xB2, 0x94, 0x7C, 0xEF, 0x58, 0xCE, 0x8D, 0x73, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x78, 0xCE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x30, 0x84, 0x54, 0xAD, 0xFE, 0xFF, 0x34, 0xA5, 0xFE, 0xFF, 0xFE, 0xFF, 0x71, 0x8C, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0x2F, 0x84, 0xFF, 0xFF, 0xBD, 0xF7, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0x0F, 0x84, 0xFF, 0xFF, 0x37, 0xC6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFF, 0xFF, 0xEF, 0x7B, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xB2, 0x94, 0xFF, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, 0xFE, 0xFF, 0x17, 0xC6, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xEF, 0x7B, 0x00, 0x00, 0x08, 0x42, 0xB6, 0xB5, 0x00, 0x00, 0xCB, 0x5A, + 0x9C, 0xF7, 0x0B, 0x63, 0xFF, 0xFF, 0x1A, 0xE7, 0x00, 0x00, 0x20, 0x00, 0x04, 0x21, 0x00, 0x00, + 0x38, 0xC6, 0x9A, 0xD6, 0xB6, 0xB5, 0x38, 0xC6, 0xFB, 0xDE, 0x5D, 0xEF, 0xBA, 0xD6, 0x1C, 0xE7, + 0xEF, 0x7B, 0xD7, 0xBD, 0xC3, 0x18, 0x34, 0xA5, 0x59, 0xCE, 0xDB, 0xDE, 0xF7, 0xBD, 0x79, 0xCE, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0x00, 0x00, 0xFE, 0xFF, 0xEE, 0x7B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x69, 0x4A, 0x00, 0x00, 0x20, 0x00, 0x96, 0xB5, 0x38, 0xC6, 0x71, 0x8C, 0xD7, 0xBD, + 0x00, 0x00, 0x00, 0x00, 0xB2, 0x94, 0x00, 0x00, 0xC7, 0x39, 0x96, 0xB5, 0x20, 0x00, 0x30, 0x84, + 0x7D, 0xEF, 0xBE, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9A, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x7D, 0xEF, + 0x18, 0xC6, 0x9A, 0xD6, 0xD7, 0xBD, 0x59, 0xCE, 0xFB, 0xDE, 0x5D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, + 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, 0xDB, 0xDE, 0xD3, 0x9C, 0xBA, 0xD6, 0xEB, 0x5A, + 0x5D, 0xEF, 0xFB, 0xDE, 0x3C, 0xE7, 0xFB, 0xDE, 0x79, 0xCE, 0x24, 0x21, 0x96, 0xB5, 0x41, 0x08, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0x3C, 0xE7, 0xDB, 0xDE, 0x1C, 0xE7, 0xBA, 0xD6, 0x71, 0x8C, 0x00, 0x00, 0x6D, 0x6B, 0x00, 0x00, + 0x1C, 0xE7, 0xBA, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0x8A, 0x52, 0x00, 0x00, 0x08, 0x42, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x29, 0xF6, 0xBD, 0xFF, 0xFF, 0x5C, 0xEF, 0xFE, 0xFF, + 0x00, 0x00, 0xEE, 0x7B, 0x00, 0x00, 0x95, 0xB5, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xB9, 0xD6, 0x45, 0x29, 0x5C, 0xEF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xAA, 0x52, 0xBD, 0xF7, 0x2C, 0x63, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xDE, 0xFF, 0xEF, 0x7B, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xF6, 0xBD, 0x33, 0xA5, 0x50, 0x8C, 0xBD, 0xF7, + 0xCE, 0x7B, 0xDD, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xDE, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xD6, 0xBD, 0xFF, 0xFF, 0xD6, 0xBD, 0x00, 0x00, 0xCA, 0x5A, 0x00, 0x00, 0xAA, 0x52, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0x37, 0xC6, 0x00, 0x00, 0x89, 0x52, 0x00, 0x00, 0x28, 0x42, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3B, 0xE7, 0xBD, 0xF7, 0xD2, 0x9C, 0x6D, 0x6B, 0x00, 0x00, + 0xFF, 0xFF, 0x75, 0xAD, 0xB5, 0xB5, 0x00, 0x00, 0x00, 0x00, 0xA2, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, + 0xDD, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xBD, 0xF7, 0xFE, 0xFF, 0x9D, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0xFF, 0xFF, 0xFA, 0xDE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xFF, 0xFF, 0x33, 0xA5, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFE, 0xFF, 0xDE, 0xFF, 0x37, 0xC6, 0xFF, 0xFF, 0x91, 0x94, 0x9D, 0xF7, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x99, 0xD6, 0x95, 0xB5, 0xFE, 0xFF, 0xD2, 0x9C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0xFF, 0xFF, 0xF2, 0x9C, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xDA, 0xDE, 0x75, 0xAD, 0xFE, 0xFF, 0xD2, 0x9C, 0xFF, 0xFF, 0xFE, 0xFF, 0x9C, 0xF7, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x78, 0xCE, 0x00, 0x00, 0xDE, 0xFF, 0x4C, 0x6B, 0x00, 0x00, 0x58, 0xCE, 0x00, 0x00, 0xEE, 0x7B, + 0xFF, 0xFF, 0xF6, 0xBD, 0xFE, 0xFF, 0x7C, 0xEF, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x31, 0x00, 0x00, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x37, 0xC6, 0xFF, 0xFF, 0x00, 0x00, 0x17, 0xC6, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x71, 0x8C, 0x00, 0x00, 0x37, 0xC6, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x5C, 0xEF, 0x45, 0x29, 0xFE, 0xFF, 0xAE, 0x73, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD6, 0xBD, 0xFE, 0xFF, 0x00, 0x00, 0x74, 0xAD, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x91, 0x94, 0x9D, 0xF7, 0x00, 0x00, 0xCA, 0x5A, 0xFF, 0xFF, 0xFE, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFA, 0xDE, 0x7C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x3B, 0xE7, 0x61, 0x08, 0xFE, 0xFF, 0x91, 0x94, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x41, 0x08, + 0xFF, 0xFF, 0xFA, 0xDE, 0xFE, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7B, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x37, 0xC6, 0x00, 0x00, 0x5C, 0xEF, 0x04, 0x21, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x7C, 0xEF, 0xC7, 0x39, 0xDA, 0xDE, 0x00, 0x00, + 0x75, 0xAD, 0x18, 0xC6, 0x92, 0x94, 0xD7, 0xBD, 0x9A, 0xD6, 0x1C, 0xE7, 0x59, 0xCE, 0xDB, 0xDE, + 0x69, 0x4A, 0x96, 0xB5, 0xA2, 0x10, 0x34, 0xA5, 0x38, 0xC6, 0xBA, 0xD6, 0xF7, 0xBD, 0x9A, 0xD6, + 0x5D, 0xEF, 0x9E, 0xF7, 0x3C, 0xE7, 0x9E, 0xF7, 0xBE, 0xF7, 0xFF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x00, 0x00, 0xEF, 0x7B, 0x00, 0x00, 0xEB, 0x5A, 0xD7, 0xBD, 0x79, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, + 0x00, 0x00, 0xAA, 0x52, 0x00, 0x00, 0x4D, 0x6B, 0xB6, 0xB5, 0x59, 0xCE, 0xB6, 0xB5, 0x59, 0xCE, + 0xDB, 0xDE, 0x5D, 0xEF, 0xDB, 0xDE, 0x3C, 0xE7, 0x9E, 0xF7, 0xDF, 0xFF, 0x7D, 0xEF, 0xBE, 0xF7, + 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x5D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0xE7, 0x39, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, + 0xFB, 0xDE, 0x9A, 0xD6, 0xFB, 0xDE, 0x9A, 0xD6, 0x49, 0x4A, 0x00, 0x00, 0xEB, 0x5A, 0x00, 0x00, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, + 0x1C, 0xE7, 0x9A, 0xD6, 0x1C, 0xE7, 0xBA, 0xD6, 0xEF, 0x7B, 0x00, 0x00, 0x14, 0xA5, 0x20, 0x00, + 0x3C, 0xE7, 0xDB, 0xDE, 0x3C, 0xE7, 0xDB, 0xDE, 0x18, 0xC6, 0xE3, 0x18, 0x59, 0xCE, 0x69, 0x4A, + 0x8D, 0x73, 0xFE, 0xFF, 0x6D, 0x6B, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xEB, 0x5A, 0xDD, 0xFF, 0xE7, 0x39, 0x9C, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0xFA, 0xDE, 0x00, 0x00, 0xF6, 0xBD, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x30, 0x84, 0x00, 0x00, 0xC6, 0x39, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0xDE, 0xBD, 0xF7, 0x54, 0xAD, 0xEB, 0x5A, 0x00, 0x00, + 0xFE, 0xFF, 0xFF, 0xFF, 0x7C, 0xEF, 0xB6, 0xB5, 0xDE, 0xFF, 0xFA, 0xDE, 0x4C, 0x6B, 0x00, 0x00, + 0xA6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x18, 0x49, 0x4A, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xDE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDA, 0xDE, 0xF2, 0x9C, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x3B, 0xE7, 0x50, 0x8C, + 0x7C, 0xEF, 0x54, 0xAD, 0xA6, 0x31, 0x00, 0x00, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x74, 0xAD, 0x2C, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x20, 0x00, 0x04, 0x21, 0xCF, 0x7B, 0xB2, 0x94, 0x8A, 0x52, 0x10, 0x84, 0xF3, 0x9C, 0x34, 0xA5, + 0x00, 0x00, 0x00, 0x00, 0x65, 0x29, 0x6D, 0x6B, 0x24, 0x21, 0x6D, 0x6B, 0xD3, 0x9C, 0x14, 0xA5, + 0xF3, 0x9C, 0x34, 0xA5, 0x75, 0xAD, 0xB6, 0xB5, 0x75, 0xAD, 0xB6, 0xB5, 0xF7, 0xBD, 0x59, 0xCE, + 0x17, 0xC6, 0x85, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x39, + 0x00, 0x00, 0x82, 0x10, 0xA6, 0x31, 0x30, 0x84, 0x0C, 0x63, 0x71, 0x8C, 0xB2, 0x94, 0xF3, 0x9C, + 0x04, 0x21, 0x4D, 0x6B, 0xEF, 0x7B, 0xEF, 0x7B, 0x45, 0x29, 0x00, 0x00, 0x49, 0x4A, 0x00, 0x00, + 0x71, 0x8C, 0x92, 0x94, 0xF3, 0x9C, 0x14, 0xA5, 0xAE, 0x73, 0x00, 0x00, 0xD3, 0x9C, 0x04, 0x21, + 0xD3, 0x9C, 0x14, 0xA5, 0x75, 0xAD, 0xB6, 0xB5, 0x55, 0xAD, 0x96, 0xB5, 0xD7, 0xBD, 0x18, 0xC6, + 0xF7, 0xBD, 0x38, 0xC6, 0x79, 0xCE, 0xBA, 0xD6, 0x59, 0xCE, 0x9A, 0xD6, 0xDB, 0xDE, 0xFB, 0xDE, + 0x96, 0xB5, 0x96, 0xB5, 0x18, 0xC6, 0x18, 0xC6, 0x55, 0xAD, 0xEB, 0x5A, 0xD7, 0xBD, 0xF3, 0x9C, + 0x79, 0xCE, 0x79, 0xCE, 0xFB, 0xDE, 0xDB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0x9A, 0xD6, 0x59, 0xCE, + 0x8D, 0x73, 0xFE, 0xFF, 0x24, 0x21, 0x5C, 0xEF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x17, 0xC6, 0x00, 0x00, 0xCE, 0x7B, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0xFA, 0xDE, 0xFF, 0xFF, 0x91, 0x94, 0xFE, 0xFF, + 0x8A, 0x52, 0x00, 0x00, 0x55, 0xAD, 0x82, 0x10, 0x00, 0x00, 0xB9, 0xD6, 0x00, 0x00, 0x0B, 0x63, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0x78, 0xCE, 0xFE, 0xFF, 0xDD, 0xFF, 0xF6, 0xBD, 0xFF, 0xFF, 0xB2, 0x94, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xD6, 0xBD, 0xB9, 0xD6, 0x5B, 0xEF, 0x13, 0xA5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xF3, 0x9C, 0xFF, 0xFF, 0x98, 0xD6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xFE, 0xFF, + 0x7C, 0xEF, 0xFE, 0xFF, 0x99, 0xD6, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xB9, 0xD6, 0xFE, 0xFF, 0xDE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x74, 0xAD, 0xFF, 0xFF, 0x99, 0xD6, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0x7C, 0xEF, 0xFE, 0xFF, 0xDE, 0xFF, + 0x00, 0x00, 0x61, 0x08, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0x04, 0x21, 0xAA, 0x52, 0x6D, 0x6B, + 0x85, 0x31, 0x00, 0x00, 0x4C, 0x6B, 0x00, 0x00, 0x08, 0x42, 0xAE, 0x73, 0x65, 0x29, 0xEF, 0x7B, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, + 0xB1, 0x94, 0x00, 0x00, 0xB6, 0xB5, 0x00, 0x00, 0xE3, 0x18, 0x30, 0x84, 0x61, 0x08, 0x10, 0x84, + 0x99, 0xD6, 0x00, 0x00, 0x3B, 0xE7, 0x00, 0x00, 0x00, 0x00, 0xAE, 0x73, 0x00, 0x00, 0x2C, 0x63, + 0x00, 0x00, 0x00, 0x00, 0x28, 0x42, 0x41, 0x08, 0x00, 0x00, 0x30, 0x84, 0x00, 0x00, 0x00, 0x00, + 0xEF, 0x7B, 0xAE, 0x73, 0x51, 0x8C, 0x92, 0x94, 0xC7, 0x39, 0x41, 0x08, 0x92, 0x94, 0x30, 0x84, + 0xDA, 0xDE, 0xFE, 0xFF, 0x00, 0x00, 0xAD, 0x73, 0xFF, 0xFF, 0xFF, 0xFF, 0xD6, 0xBD, 0x1A, 0xE7, + 0x00, 0x00, 0x00, 0x00, 0x69, 0x4A, 0xE3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x92, 0x94, 0xD3, 0x9C, 0xD3, 0x9C, 0x34, 0xA5, 0x14, 0xA5, 0x34, 0xA5, 0x75, 0xAD, 0xB6, 0xB5, + 0xF3, 0x9C, 0x75, 0xAD, 0x14, 0xA5, 0x96, 0xB5, 0xB6, 0xB5, 0x18, 0xC6, 0xF7, 0xBD, 0x59, 0xCE, + 0x34, 0xA5, 0x14, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, 0x30, 0x84, 0x2C, 0x63, 0xB6, 0xB5, 0x96, 0xB5, + 0x18, 0xC6, 0x38, 0xC6, 0x9A, 0xD6, 0xBA, 0xD6, 0x38, 0xC6, 0x38, 0xC6, 0xBA, 0xD6, 0xBA, 0xD6, + 0xFE, 0xFF, 0xFE, 0xFF, 0x9D, 0xF7, 0xDD, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xBD, 0xF7, 0x5B, 0xEF, + 0x28, 0x42, 0xAA, 0x52, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x52, 0xE3, 0x18, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xBD, 0xF7, 0xB6, 0xB5, 0xCA, 0x5A, 0x78, 0xCE, 0xD2, 0x9C, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, 0x61, 0x08, 0xAA, 0x52, 0x30, 0x84, + 0x69, 0x4A, 0x08, 0x42, 0x96, 0xB5, 0x75, 0xAD, 0x08, 0x42, 0xAA, 0x52, 0x75, 0xAD, 0x75, 0xAD, + 0x18, 0xC6, 0x18, 0xC6, 0xBA, 0xD6, 0x9A, 0xD6, 0x18, 0xC6, 0x18, 0xC6, 0x9A, 0xD6, 0x9A, 0xD6, + 0xCF, 0x7B, 0xD3, 0x9C, 0x75, 0xAD, 0x96, 0xB5, 0x14, 0xA5, 0x14, 0xA5, 0xB6, 0xB5, 0xB6, 0xB5, + 0x18, 0xC6, 0x38, 0xC6, 0xBA, 0xD6, 0xBA, 0xD6, 0x38, 0xC6, 0x59, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, + 0xCE, 0x7B, 0xEF, 0x7B, 0x00, 0x00, 0x00, 0x00, 0x33, 0xA5, 0xB9, 0xD6, 0x00, 0x00, 0x00, 0x00, + 0x24, 0x21, 0x04, 0x21, 0x92, 0x94, 0xB2, 0x94, 0x41, 0x08, 0x00, 0x00, 0x30, 0x84, 0x4D, 0x6B, + 0x9D, 0xF7, 0xBD, 0xF7, 0x08, 0x42, 0x48, 0x4A, 0x2F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x49, 0x4A, 0x28, 0x42, 0x00, 0x00, 0x65, 0x29, 0x4D, 0x6B, 0x55, 0xAD, + 0x34, 0xA5, 0x55, 0xAD, 0xD7, 0xBD, 0xF7, 0xBD, 0x55, 0xAD, 0x75, 0xAD, 0xF7, 0xBD, 0x18, 0xC6, + 0x79, 0xCE, 0x79, 0xCE, 0xFB, 0xDE, 0xFB, 0xDE, 0x9A, 0xD6, 0x9A, 0xD6, 0x1C, 0xE7, 0x1C, 0xE7, + 0x96, 0xB5, 0x96, 0xB5, 0x18, 0xC6, 0x38, 0xC6, 0xD7, 0xBD, 0xF7, 0xBD, 0x59, 0xCE, 0x79, 0xCE, + 0x9A, 0xD6, 0xBA, 0xD6, 0x1C, 0xE7, 0x3C, 0xE7, 0xDB, 0xDE, 0xFB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, + 0x41, 0x08, 0xB2, 0x94, 0x28, 0x42, 0x96, 0xB5, 0xD7, 0xBD, 0x79, 0xCE, 0x18, 0xC6, 0x9A, 0xD6, + 0x34, 0xA5, 0xD7, 0xBD, 0xD7, 0xBD, 0x38, 0xC6, 0x59, 0xCE, 0xBA, 0xD6, 0x9A, 0xD6, 0xFB, 0xDE, + 0xDB, 0xDE, 0x5D, 0xEF, 0xFB, 0xDE, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x59, 0xCE, 0x9A, 0xD6, 0xBA, 0xD6, 0xFB, 0xDE, 0xDB, 0xDE, 0x3C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, + 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, + 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x5D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0x1C, 0xE7, 0x79, 0xCE, 0x51, 0x8C, 0xBA, 0xD6, 0xF7, 0xBD, + 0x7D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0xDB, 0xDE, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0xDB, 0xDE, 0x5D, 0xEF, 0x1C, 0xE7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0x7D, 0xEF, + 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, 0x17, 0xC6, 0xFF, 0xFF, 0x2C, 0x63, 0xDD, 0xFF, + 0x4D, 0x6B, 0x00, 0x00, 0xF7, 0xBD, 0x24, 0x21, 0x00, 0x00, 0x95, 0xB5, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xB9, 0xD6, + 0xFF, 0xFF, 0xFF, 0xFF, 0xB5, 0xB5, 0xDA, 0xDE, 0x1B, 0xE7, 0xE7, 0x39, 0xCA, 0x5A, 0x00, 0x00, + 0x79, 0xCE, 0xD3, 0x9C, 0xBA, 0xD6, 0x59, 0xCE, 0x61, 0x08, 0x00, 0x00, 0xB2, 0x94, 0x04, 0x21, + 0xFB, 0xDE, 0xBA, 0xD6, 0x3C, 0xE7, 0x1C, 0xE7, 0x59, 0xCE, 0xD7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x8A, 0x52, + 0x51, 0x8C, 0x8E, 0x73, 0x59, 0xCE, 0x38, 0xC6, 0x92, 0x94, 0x96, 0xB5, 0x38, 0xC6, 0x38, 0xC6, + 0x99, 0xD6, 0x03, 0x21, 0x82, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x49, 0x4A, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xCB, 0x5A, 0xCB, 0x5A, 0x92, 0x94, 0xB2, 0x94, 0x14, 0xA5, + 0x04, 0x21, 0x2C, 0x63, 0x71, 0x8C, 0xB2, 0x94, 0x71, 0x8C, 0xD3, 0x9C, 0x14, 0xA5, 0x75, 0xAD, + 0xF3, 0x9C, 0x55, 0xAD, 0x75, 0xAD, 0xD7, 0xBD, 0x96, 0xB5, 0xF7, 0xBD, 0x38, 0xC6, 0x79, 0xCE, + 0x8A, 0x52, 0xF3, 0x9C, 0x34, 0xA5, 0x75, 0xAD, 0x55, 0xAD, 0x96, 0xB5, 0xD7, 0xBD, 0x38, 0xC6, + 0xD7, 0xBD, 0xF7, 0xBD, 0x59, 0xCE, 0x9A, 0xD6, 0x59, 0xCE, 0x9A, 0xD6, 0xBA, 0xD6, 0xFB, 0xDE, + 0xF7, 0xBD, 0x59, 0xCE, 0x79, 0xCE, 0xDB, 0xDE, 0x9A, 0xD6, 0xDB, 0xDE, 0x1C, 0xE7, 0x5D, 0xEF, + 0xDB, 0xDE, 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, + 0x14, 0xA5, 0x55, 0xAD, 0xB6, 0xB5, 0xF7, 0xBD, 0x96, 0xB5, 0xD7, 0xBD, 0x38, 0xC6, 0x79, 0xCE, + 0x38, 0xC6, 0x79, 0xCE, 0xBA, 0xD6, 0xFB, 0xDE, 0xBA, 0xD6, 0xDB, 0xDE, 0x1C, 0xE7, 0x5D, 0xEF, + 0x18, 0xC6, 0x59, 0xCE, 0x9A, 0xD6, 0xDB, 0xDE, 0x79, 0xCE, 0xBA, 0xD6, 0xFB, 0xDE, 0x3C, 0xE7, + 0xFB, 0xDE, 0x3C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, + 0x1C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, + 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFB, 0xDE, 0x1C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, + 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x3C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0xDB, 0xDE, 0x9A, 0xD6, 0x3C, 0xE7, 0xDB, 0xDE, + 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0x5D, 0xEF, 0x1C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, + 0x18, 0xC6, 0x8E, 0x73, 0x79, 0xCE, 0xF7, 0xBD, 0x00, 0x00, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, + 0xBA, 0xD6, 0x59, 0xCE, 0xFB, 0xDE, 0xBA, 0xD6, 0x96, 0xB5, 0x24, 0x21, 0x38, 0xC6, 0x14, 0xA5, + 0xB1, 0x94, 0xFE, 0xFF, 0x00, 0x00, 0x54, 0xAD, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, 0x74, 0xAD, 0xFE, 0xFF, 0x00, 0x00, 0xF2, 0x9C, + 0x3C, 0xE7, 0xFB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, 0x9A, 0xD6, 0x18, 0xC6, 0xDB, 0xDE, 0x79, 0xCE, + 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x5D, 0xEF, 0x3C, 0xE7, + 0xF3, 0x9C, 0x04, 0x21, 0x18, 0xC6, 0x34, 0xA5, 0x00, 0x00, 0x00, 0x00, 0x86, 0x31, 0x00, 0x00, + 0x79, 0xCE, 0x18, 0xC6, 0xDB, 0xDE, 0x79, 0xCE, 0x96, 0xB5, 0x8A, 0x52, 0x18, 0xC6, 0xB6, 0xB5, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xDD, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xCE, 0x7B, 0x5B, 0xEF, 0x00, 0x00, 0xA6, 0x31, 0xFF, 0xFF, 0xFE, 0xFF, 0xF6, 0xBD, 0xDE, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0xEF, 0x7B, 0xE3, 0x18, 0x00, 0x00, 0x6D, 0x6B, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x99, 0xD6, 0xFE, 0xFF, 0x00, 0x00, 0x8D, 0x73, 0xFF, 0xFF, 0xFE, 0xFF, 0x58, 0xCE, 0xDD, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x9D, 0xF7, 0x28, 0x42, 0xDE, 0xFF, 0x6C, 0x6B, 0x00, 0x00, 0x69, 0x4A, 0x00, 0x00, 0xC7, 0x39, + 0xFE, 0xFF, 0x70, 0x8C, 0xFF, 0xFF, 0x54, 0xAD, 0x00, 0x00, 0x24, 0x21, 0x00, 0x00, 0xA2, 0x10, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFF, 0xFF, 0x17, 0xC6, 0xFF, 0xFF, 0xB9, 0xD6, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x1B, 0xE7, 0xFE, 0xFF, 0x5C, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x44, 0x29, 0x00, 0x00, + 0x14, 0xA5, 0xB6, 0xB5, 0x14, 0xA5, 0xB6, 0xB5, 0x18, 0xC6, 0x9A, 0xD6, 0x38, 0xC6, 0xBA, 0xD6, + 0x14, 0xA5, 0xB6, 0xB5, 0xD3, 0x9C, 0xB6, 0xB5, 0x38, 0xC6, 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, + 0xDB, 0xDE, 0xFB, 0xDE, 0xFB, 0xDE, 0x3C, 0xE7, 0x1C, 0xE7, 0x1C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, + 0x1C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, + 0x71, 0x8C, 0x96, 0xB5, 0xEF, 0x7B, 0x96, 0xB5, 0x38, 0xC6, 0xBA, 0xD6, 0x18, 0xC6, 0xBA, 0xD6, + 0x8E, 0x73, 0x75, 0xAD, 0x0C, 0x63, 0x75, 0xAD, 0x18, 0xC6, 0xBA, 0xD6, 0xF7, 0xBD, 0x9A, 0xD6, + 0x1C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x7D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x1C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x1C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, + 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x1C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x7D, 0xEF, 0x3C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, + 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0x5D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, + 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xFB, 0xDE, 0x7D, 0xEF, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x9A, 0xD6, 0x3C, 0xE7, 0x1C, 0xE7, 0x9A, 0xD6, 0xBA, 0xD6, 0x1C, 0xE7, 0x1C, 0xE7, + 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x5D, 0xEF, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDB, 0xDE, 0xFB, 0xDE, 0x3C, 0xE7, 0x5D, 0xEF, 0x1C, 0xE7, 0x5D, 0xEF, 0x7D, 0xEF, 0x9E, 0xF7, + 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x5D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, + 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, 0x9A, 0xD6, 0x38, 0xC6, 0xFB, 0xDE, 0xBA, 0xD6, + 0x9E, 0xF7, 0x7D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x3C, 0xE7, 0x1C, 0xE7, 0x7D, 0xEF, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xD7, 0xBD, 0x55, 0xAD, 0x59, 0xCE, 0x18, 0xC6, 0xCB, 0x5A, 0x82, 0x10, 0xB6, 0xB5, 0xF3, 0x9C, + 0xBA, 0xD6, 0x79, 0xCE, 0x3C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xD7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x00, 0x00, 0x00, 0x00, 0xAA, 0x52, 0xA2, 0x10, 0x00, 0x00, 0x2C, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x96, 0xB5, 0xF3, 0x9C, 0x38, 0xC6, 0xD7, 0xBD, 0x0C, 0x63, 0xE3, 0x18, 0x96, 0xB5, 0x34, 0xA5, + 0x7D, 0xEF, 0x3C, 0xE7, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0x9A, 0xD6, 0x59, 0xCE, 0x1C, 0xE7, 0xDB, 0xDE, 0x18, 0xC6, 0xD7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x5D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x3C, 0xE7, + 0x17, 0xC6, 0xBD, 0xF7, 0x00, 0x00, 0x89, 0x52, 0xFF, 0xFF, 0xFE, 0xFF, 0x95, 0xB5, 0x7C, 0xEF, + 0x00, 0x00, 0x00, 0x00, 0x4D, 0x6B, 0x24, 0x21, 0x00, 0x00, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0x54, 0xAD, 0x5C, 0xEF, 0x00, 0x00, 0x85, 0x31, 0xFF, 0xFF, 0xFF, 0xFF, 0x13, 0xA5, 0x5C, 0xEF, + 0x96, 0xB5, 0x55, 0xAD, 0x38, 0xC6, 0xF7, 0xBD, 0xAE, 0x73, 0x45, 0x29, 0x96, 0xB5, 0x55, 0xAD, + 0x9A, 0xD6, 0x79, 0xCE, 0x1C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x00, 0x00, 0x00, 0x00, 0xCF, 0x7B, 0x86, 0x31, 0x00, 0x00, 0x45, 0x29, 0x00, 0x00, 0x00, 0x00, + 0x96, 0xB5, 0x55, 0xAD, 0x38, 0xC6, 0xF7, 0xBD, 0xEF, 0x7B, 0x65, 0x29, 0xB6, 0xB5, 0x55, 0xAD, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0x48, 0x4A, 0x00, 0x00, 0x89, 0x52, 0x00, 0x00, + 0xFE, 0xFF, 0xBD, 0xF7, 0xFE, 0xFF, 0xBD, 0xF7, 0x89, 0x52, 0x00, 0x00, 0x69, 0x4A, 0x00, 0x00, + 0x33, 0xA5, 0x5C, 0xEF, 0x00, 0x00, 0x86, 0x31, 0xFF, 0xFF, 0xFF, 0xFF, 0x54, 0xAD, 0x5C, 0xEF, + 0x00, 0x00, 0x00, 0x00, 0xEF, 0x7B, 0x65, 0x29, 0x00, 0x00, 0x85, 0x31, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0x5B, 0xEF, 0xFF, 0xFF, 0xF7, 0xBD, 0xC3, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0F, 0x84, 0xE7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x21, 0x20, 0x00, 0xEF, 0x7B, + 0xCB, 0x5A, 0x55, 0xAD, 0x8A, 0x52, 0x55, 0xAD, 0xF7, 0xBD, 0x9A, 0xD6, 0xF7, 0xBD, 0x9A, 0xD6, + 0x8A, 0x52, 0x75, 0xAD, 0xCB, 0x5A, 0x75, 0xAD, 0xF7, 0xBD, 0x9A, 0xD6, 0x18, 0xC6, 0x9A, 0xD6, + 0x1C, 0xE7, 0x7D, 0xEF, 0xFB, 0xDE, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0xFB, 0xDE, 0x7D, 0xEF, 0x1C, 0xE7, 0x7D, 0xEF, 0x9E, 0xF7, 0xDF, 0xFF, 0x9E, 0xF7, 0xDF, 0xFF, + 0x4D, 0x6B, 0x96, 0xB5, 0x30, 0x84, 0xB6, 0xB5, 0x18, 0xC6, 0xBA, 0xD6, 0x38, 0xC6, 0xDB, 0xDE, + 0x75, 0xAD, 0xF7, 0xBD, 0xB6, 0xB5, 0x38, 0xC6, 0x79, 0xCE, 0xFB, 0xDE, 0x9A, 0xD6, 0x1C, 0xE7, + 0x1C, 0xE7, 0x7D, 0xEF, 0x3C, 0xE7, 0x7D, 0xEF, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xDF, 0xFF, + 0x3C, 0xE7, 0x9E, 0xF7, 0x5D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x7D, 0xEF, 0xDF, 0xFF, 0xBE, 0xF7, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x5D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xDB, 0xDE, 0x7D, 0xEF, 0x5D, 0xEF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xBE, 0xF7, + 0xBA, 0xD6, 0x79, 0xCE, 0x1C, 0xE7, 0xFB, 0xDE, 0x38, 0xC6, 0xF7, 0xBD, 0xBA, 0xD6, 0x79, 0xCE, + 0x5D, 0xEF, 0x3C, 0xE7, 0xBE, 0xF7, 0x9E, 0xF7, 0x1C, 0xE7, 0xFB, 0xDE, 0x7D, 0xEF, 0x5D, 0xEF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xBE, 0xF7, 0xFF, 0xFF, 0xDF, 0xFF, 0x9E, 0xF7, 0x9E, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xB6, 0xB5, 0x75, 0xAD, 0x59, 0xCE, 0x18, 0xC6, 0x30, 0x84, 0x28, 0x42, 0xF7, 0xBD, 0xD7, 0xBD, + 0xBA, 0xD6, 0x9A, 0xD6, 0x3C, 0xE7, 0x1C, 0xE7, 0x79, 0xCE, 0x59, 0xCE, 0xFB, 0xDE, 0xDB, 0xDE, + 0x24, 0x21, 0x86, 0x31, 0xD7, 0xBD, 0xD7, 0xBD, 0x10, 0x84, 0xB6, 0xB5, 0x18, 0xC6, 0x38, 0xC6, + 0x59, 0xCE, 0x59, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, 0x79, 0xCE, 0x9A, 0xD6, 0xFB, 0xDE, 0x1C, 0xE7, + 0x7D, 0xEF, 0x5D, 0xEF, 0xBE, 0xF7, 0xBE, 0xF7, 0x5D, 0xEF, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x3C, 0xE7, 0x3C, 0xE7, 0x9E, 0xF7, 0x9E, 0xF7, 0x3C, 0xE7, 0x5D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, + 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, + 0x18, 0xC6, 0x79, 0xCE, 0x79, 0xCE, 0xDB, 0xDE, 0xDB, 0xDE, 0x3C, 0xE7, 0x1C, 0xE7, 0x5D, 0xEF, + 0xDB, 0xDE, 0x1C, 0xE7, 0x3C, 0xE7, 0x5D, 0xEF, 0x5D, 0xEF, 0x9E, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, + 0x7D, 0xEF, 0xBE, 0xF7, 0x9E, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, + 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x7D, 0xEF, 0x9E, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xBE, 0xF7, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, + 0xDF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x43, 0x4C, 0x49, 0x4D, 0xFF, 0xFE, 0x14, 0x00, 0x00, 0x00, 0x02, 0x02, 0x28, 0x80, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x69, 0x6D, 0x61, 0x67, 0x10, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00 +}; diff --git a/plugin/sources/main.cpp b/plugin/sources/main.cpp new file mode 100644 index 0000000..f7af08e --- /dev/null +++ b/plugin/sources/main.cpp @@ -0,0 +1,340 @@ +#include "Main.hpp" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "ArticProtocolServer.hpp" +#include "ArticFunctions.hpp" +#include "CTRPluginFramework/Clock.hpp" +#include "plgldr.h" + +#include "BCLIM.hpp" + +#include "logo.h" + +#define SOC_ALIGN 0x1000 +#define SOC_BUFFERSIZE 0x400000 + +Logger logger; +static bool should_run = true; +static int listen_fd = -1; +static int accept_fd = -1; +static ArticProtocolServer* articBase = nullptr; +static bool reloadBottomText = false; + +int transferedBytes = 0; + +extern "C" { + #include "csvc.h" +} + +void DisableSleep(void) +{ + u8 reg; + + if (R_FAILED(mcuHwcInit())) + return; + + if (R_FAILED(MCUHWC_ReadRegister(0x18, ®, 1))) + return; + + reg |= 0x60; ///< Disable home btn & shell state events + MCUHWC_WriteRegister(0x18, ®, 1); + mcuHwcExit(); +} + +void EnableSleep(void) +{ + u8 reg; + + if (R_FAILED(mcuHwcInit())) + return; + + if (R_FAILED(MCUHWC_ReadRegister(0x18, ®, 1))) + return; + + reg &= ~0x60; ///< Enable home btn & shell state events + MCUHWC_WriteRegister(0x18, ®, 1); + mcuHwcExit(); +} + +void Start(void* arg) { + int res; + void* SOC_buffer = memalign(SOC_ALIGN, SOC_BUFFERSIZE); + if ((res = socInit((u32*)SOC_buffer, SOC_BUFFERSIZE)) != 0) { + free(SOC_buffer); + logger.Error("Server: Cannot initialize sockets"); + return; + } + while (should_run) { + svcSleepThread(500000000); + struct sockaddr_in servaddr = {0}; + listen_fd = socket(AF_INET, SOCK_STREAM, 0); + if (listen_fd < 0) { + logger.Error("Server: Cannot create socket"); + continue; + } + + if (!ArticProtocolServer::SetNonBlock(listen_fd, true)) { + logger.Error("Server:: Failed to set non-block"); + close(listen_fd); + listen_fd = -1; + continue; + } + + servaddr.sin_family = AF_INET; + servaddr.sin_addr.s_addr = htonl(INADDR_ANY); + servaddr.sin_port = htons(SERVER_PORT); + res = bind(listen_fd, (struct sockaddr *) &servaddr, sizeof(servaddr)); + if (res < 0) { + logger.Error("Server: Failed to bind() to port %d", SERVER_PORT); + close(listen_fd); + listen_fd = -1; + continue; + } + + res = listen(listen_fd, 1); + if (res < 0) { + if (should_run) { + logger.Error("Server: Failed to listen()"); + } + close(listen_fd); + listen_fd = -1; + continue; + } + + struct in_addr host_id; + host_id.s_addr = gethostid(); + logger.Info("Server: Listening on: %s:%d", inet_ntoa(host_id), SERVER_PORT); + + struct sockaddr_in peeraddr = {0}; + socklen_t peeraddr_len = sizeof(peeraddr); + bool error = false; + while (true) { + accept_fd = accept(listen_fd, (struct sockaddr *) &peeraddr, &peeraddr_len); + if (accept_fd < 0 || peeraddr_len == 0) { + if (errno == EWOULDBLOCK && should_run) { + svcSleepThread(10000000); + continue; + } + if (should_run) { + logger.Error("Server: Failed to accept()"); + } + error = true; + break; + } + break; + } + if (listen_fd >= 0) { + close(listen_fd); + listen_fd = -1; + } + if (error) + continue; + + logger.Info("Server: Connected: %s:%d", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port)); + + if (!ArticProtocolServer::SetNonBlock(accept_fd, true)) { + logger.Error("Server: Failed to set non-block"); + shutdown(accept_fd, SHUT_RDWR); + close(accept_fd); + accept_fd = -1; + continue; + } + + articBase = new ArticProtocolServer(accept_fd); + articBase->Serve(); + accept_fd = -1; + delete articBase; + articBase = nullptr; + logger.Info("Server: Disconnected"); + + for (auto it = ArticBaseFunctions::destructFunctions.begin(); it != ArticBaseFunctions::destructFunctions.end(); it++) { + (*it)(); + } + } + socExit(); + free(SOC_buffer); +} + +PrintConsole topScreenConsole, bottomScreenConsole; + +void Main() { + logger.Start(); + + plgLdrInit(); + bool prevPluginState = ((PluginHeader*)0x07000000)->config[0] != 0; + PLGLDR__SetPluginLoaderState(prevPluginState); + PLGLDR__ClearPluginLoadParameters(); + plgLdrExit(); + + gspLcdInit(); + + gfxInitDefault(); + consoleInit(GFX_TOP, &topScreenConsole); + consoleInit(GFX_BOTTOM, &bottomScreenConsole); + topScreenConsole.bg = 15; topScreenConsole.fg = 0; + bottomScreenConsole.bg = 15; bottomScreenConsole.fg = 0; + + gfxSetDoubleBuffering(GFX_BOTTOM, false); + + aptSetHomeAllowed(false); + + consoleSelect(&bottomScreenConsole); + consoleClear(); + consoleSelect(&topScreenConsole); + consoleClear(); + + { + CTRPluginFramework::BCLIM((void*)__data_logo_bin, __data_logo_bin_size).Render(CTRPluginFramework::Rect((320 - 128) / 2, (240 - 128) / 2, 128, 128)); + } + + auto print_bottom_info = []() { + logger.Raw(false, "\n Azahar Artic Setup v%d.%d.%d\n\n" + " - A: Enter sleep \n" + " - X: Show debug log \n" + " - Y: Restart server \n" + " - START: Exit \n" + , VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION); + }; + + print_bottom_info(); + logger.Raw(true, ""); + + bool setupCorrect = true; + for (auto it = ArticBaseFunctions::setupFunctions.begin(); it != ArticBaseFunctions::setupFunctions.end(); it++) { + setupCorrect = (*it)() && setupCorrect; + } + + Thread serverThread = nullptr; + if (!setupCorrect) { + logger.Error("Server: Setup failed"); + } else { + s32 prio = 0; + svcGetThreadPriority(&prio, CUR_THREAD_HANDLE); + serverThread = threadCreate(Start, nullptr, 0x1000, prio-1, -2, false); + } + + CTRPluginFramework::Clock clock; + bool sleeping = false; + + DisableSleep(); + + while (aptMainLoop()) + { + if (reloadBottomText) { + reloadBottomText = false; + + print_bottom_info(); + } + + hidScanInput(); + + u32 kDown = hidKeysDown(); + u32 kHeld = hidKeysHeld(); + + if (((kDown & ~KEY_SELECT) != 0) && sleeping) { + sleeping = false; + GSPLCD_PowerOnBacklight(3); + continue; + } + + if ((kDown & KEY_A) && !sleeping) { + sleeping = true; + GSPLCD_PowerOffBacklight(3); + } + + if ((kDown & KEY_START)) { + logger.Info("Server: Exiting"); + break; + } + + if ((kDown & KEY_Y)) { + if (articBase) { + logger.Info("Server: Restarting"); + articBase->QueryStop(); + } else { + logger.Debug("Server: Not started yet."); + } + } + + if ((kDown & KEY_X)) { + if (logger.debug_enable) { + logger.Info("Server: Debug log disabled"); + logger.debug_enable = false; + } else { + logger.Info("Server: Debug log enabled"); + logger.debug_enable = true; + } + } + + if (clock.HasTimePassed(CTRPluginFramework::Seconds(1))) + { + if (articBase) { + CTRPluginFramework::Time t = clock.GetElapsedTime(); + float bytes = transferedBytes / t.AsSeconds(); + transferedBytes = 0; + float value = (bytes >= 1000 * 1000) ? (bytes / 1000.f * 1000.f) : (bytes / 1000.f); + const char* unit = (bytes >= 1000 * 1000) ? "MB/s" : "KB/s"; + logger.Traffic(" Traffic: %.02f %s \n", value, unit); + clock.Restart(); + } else { + logger.Traffic(" \n"); + } + } + + // Flush and swap framebuffers + gfxFlushBuffers(); + gfxSwapBuffers(); + + //Wait for VBlank + gspWaitForVBlank(); + } + + should_run = false; + if (listen_fd >= 0) { + close(listen_fd); + listen_fd = -1; + } + if (articBase) { + articBase->QueryStop(); + } + + if (serverThread) { + threadJoin(serverThread, U64_MAX); + threadFree(serverThread); + } + + EnableSleep(); + + // Flush and swap framebuffers + gfxFlushBuffers(); + gfxSwapBuffers(); + + //Wait for VBlank + gspWaitForVBlank(); + + gfxExit(); + gspLcdExit(); + logger.End(); +} + +extern "C" { + int main(int argc, char* argv[]); +} +// Entrypoint, game will starts when you exit this function +int main(int argc, char* argv[]) +{ + Main(); + return 0; +} diff --git a/plugin/sources/plgldr.c b/plugin/sources/plgldr.c new file mode 100644 index 0000000..3f425f7 --- /dev/null +++ b/plugin/sources/plgldr.c @@ -0,0 +1,347 @@ +#include <3ds.h> +#include "plgldr.h" +#include +#include "csvc.h" + +static Handle plgLdrHandle; +static Handle plgLdrArbiter = 0; +static s32* plgEvent; +static s32* plgReply; +static int plgLdrRefCount; +static bool isN3DS; +static OnPlgLdrEventCb_t onPlgLdrEventCb = NULL; + +static Result PLGLDR__GetArbiter(void) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(9, 0, 0); + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + plgLdrArbiter = cmdbuf[3]; + } + return res; +} + +Result plgLdrInit(void) +{ + s64 out = 0; + Result res = 0; + + svcGetSystemInfo(&out, 0x10000, 0x201); + isN3DS = out != 0; + if (AtomicPostIncrement(&plgLdrRefCount) == 0) + res = svcConnectToPort(&plgLdrHandle, "plg:ldr"); + + if (R_SUCCEEDED(res)) + { + u32 res2 = PLGLDR__GetArbiter(); + if (R_SUCCEEDED(res2) || res2 == 0xE0E01BF4) { // Succeeded or not implemented (citra) + PluginHeader *header = (PluginHeader *)0x07000000; + + plgEvent = header->plgldrEvent; + plgReply = header->plgldrReply; + } else + plgLdrExit(); + } + else + plgLdrExit(); + + return res; +} + +void plgLdrExit(void) +{ + if (AtomicDecrement(&plgLdrRefCount)) + return; + + if (plgLdrHandle) + svcCloseHandle(plgLdrHandle); + if (plgLdrArbiter) + svcCloseHandle(plgLdrArbiter); + plgLdrHandle = plgLdrArbiter = 0; +} + +Result PLGLDR__IsPluginLoaderEnabled(bool *isEnabled) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(2, 0, 0); + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + *isEnabled = cmdbuf[2]; + } + return res; +} + +Result PLGLDR__SetPluginLoaderState(bool enabled) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(3, 1, 0); + cmdbuf[1] = (u32)enabled; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__SetPluginLoadParameters(PluginLoadParameters *parameters) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(4, 2, 4); + cmdbuf[1] = (u32)parameters->noFlash | (((u32)parameters->pluginMemoryStrategy) << 8) | (((u32)parameters->persistent) << 16); + cmdbuf[2] = parameters->lowTitleId; + cmdbuf[3] = IPC_Desc_Buffer(256, IPC_BUFFER_R); + cmdbuf[4] = (u32)parameters->path; + cmdbuf[5] = IPC_Desc_Buffer(32 * sizeof(u32), IPC_BUFFER_R); + cmdbuf[6] = (u32)parameters->config; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} +void Flash(u32 color); +Result PLGLDR__DisplayMenu(PluginMenu *menu) +{ + Result res = 0; + + u32 nbItems = menu->nbItems; + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(5, 1, 8); + cmdbuf[1] = nbItems; + cmdbuf[2] = IPC_Desc_Buffer(nbItems, IPC_BUFFER_RW); + cmdbuf[3] = (u32)menu->states; + cmdbuf[4] = IPC_Desc_Buffer(MAX_BUFFER, IPC_BUFFER_R); + cmdbuf[5] = (u32)menu->title; + cmdbuf[6] = IPC_Desc_Buffer(MAX_BUFFER * nbItems, IPC_BUFFER_R); + cmdbuf[7] = (u32)menu->items; + cmdbuf[8] = IPC_Desc_Buffer(MAX_BUFFER * nbItems, IPC_BUFFER_R); + cmdbuf[9] = (u32)menu->hints; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + else Flash(0xFF0000); + + return res; +} + +Result PLGLDR__DisplayMessage(const char *title, const char *body) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(6, 0, 4); + cmdbuf[1] = IPC_Desc_Buffer(strlen(title), IPC_BUFFER_R); + cmdbuf[2] = (u32)title; + cmdbuf[3] = IPC_Desc_Buffer(strlen(body), IPC_BUFFER_R); + cmdbuf[4] = (u32)body; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__DisplayErrMessage(const char *title, const char *body, u32 error) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(7, 1, 4); + cmdbuf[1] = error; + cmdbuf[2] = IPC_Desc_Buffer(strlen(title), IPC_BUFFER_R); + cmdbuf[3] = (u32)title; + cmdbuf[4] = IPC_Desc_Buffer(strlen(body), IPC_BUFFER_R); + cmdbuf[5] = (u32)body; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__GetVersion(u32 *version) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(8, 0, 0); + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + if (cmdbuf[0] != IPC_MakeHeader(8, 2, 0)) + return 0xD900182F; + + res = cmdbuf[1]; + if (version) + *version = cmdbuf[2]; + } + return res; +} + +Result PLGLDR__GetPluginPath(char *path) +{ + if (path == NULL) + return MAKERESULT(28, 7, 254, 1014); ///< Usage, App, Invalid argument + + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(10, 0, 2); + cmdbuf[1] = IPC_Desc_Buffer(255, IPC_BUFFER_RW); + cmdbuf[2] = (u32)path; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__SetRosalinaMenuBlock(bool shouldBlock) +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(11, 1, 0); + cmdbuf[1] = (u32)shouldBlock; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +} + +Result PLGLDR__SetSwapSettings(const char* swapPath, void* encFunc, void* decFunc, void* args) +{ + Result res = 0; + + u32* trueArgs; + u32* cmdbuf = getThreadCommandBuffer(); + u32 buf[0x10] = { 0 }; + + const char* trueSwapPath; + + if (swapPath) trueSwapPath = swapPath; + else trueSwapPath = "\0"; + + if (args) trueArgs = args; + else trueArgs = buf; + + cmdbuf[0] = IPC_MakeHeader(12, 2, 4); + cmdbuf[1] = (encFunc) ? (svcConvertVAToPA(encFunc, false) | (1 << 31)) : 0; + cmdbuf[2] = (decFunc) ? (svcConvertVAToPA(decFunc, false) | (1 << 31)) : 0; + cmdbuf[3] = IPC_Desc_Buffer(16 * sizeof(u32), IPC_BUFFER_R); + cmdbuf[4] = (u32)trueArgs; + cmdbuf[5] = IPC_Desc_Buffer(strlen(trueSwapPath) + 1, IPC_BUFFER_R); + cmdbuf[6] = (u32)trueSwapPath; + + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + + return res; +} + +void PLGLDR__SetEventCallback(OnPlgLdrEventCb_t cb) +{ + onPlgLdrEventCb = cb; +} + +static s32 __ldrex__(s32 *addr) +{ + s32 val; + do + val = __ldrex(addr); + while (__strex(addr, val)); + + return val; +} + +static void __strex__(s32 *addr, s32 val) +{ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" + s32 v; + do + v = __ldrex(addr); + while (__strex(addr, val)); +#pragma GCC diagnostic pop +} + +void PLGLDR__Status(void) +{ +} + +s32 PLGLDR__FetchEvent(void) +{ + s32 event = __ldrex__(plgEvent); // exclusive read necessary? + + return event; +} + +void PLGLDR__Reply(s32 event) +{ + __strex__(plgReply, PLG_OK); + + if (event < PLG_ABOUT_TO_SWAP) + { + __strex__(plgEvent, PLG_OK); + return; + } + svcArbitrateAddress(plgLdrArbiter, (u32)plgReply, ARBITRATION_SIGNAL, 1, 0); + if (event == PLG_ABOUT_TO_SWAP) + { + __strex__(plgEvent, PLG_WAIT); + svcArbitrateAddress(plgLdrArbiter, (u32)plgEvent, ARBITRATION_WAIT_IF_LESS_THAN, PLG_OK, 0); + } + else if (event == PLG_ABOUT_TO_EXIT) { + svcExitThread(); + } + else + { + __strex__(plgEvent, PLG_OK); + } +} + +Result PLGLDR__ClearPluginLoadParameters() +{ + Result res = 0; + + u32 *cmdbuf = getThreadCommandBuffer(); + + cmdbuf[0] = IPC_MakeHeader(14, 0, 0); + if (R_SUCCEEDED((res = svcSendSyncRequest(plgLdrHandle)))) + { + res = cmdbuf[1]; + } + return res; +}