From 6123b3aa93e3d0fccd40b35554f2d037a37bc5fd Mon Sep 17 00:00:00 2001 From: omaralhami Date: Fri, 17 Jul 2026 22:52:50 +0300 Subject: [PATCH 01/10] Add PrayerTray mod --- mods/prayertray.wh.cpp | 8753 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 8753 insertions(+) create mode 100644 mods/prayertray.wh.cpp diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp new file mode 100644 index 0000000000..912a4b3f56 --- /dev/null +++ b/mods/prayertray.wh.cpp @@ -0,0 +1,8753 @@ +// ==WindhawkMod== +// @id prayertray +// @name PrayerTray +// @description Islamic prayer times on the taskbar, next to the clock. +// @version 2.0.8 +// @author Omar Alhami (mar) +// @github https://github.com/n0tmar +// @homepage https://github.com/n0tmar/PrayerTray +// @include explorer.exe +// @architecture x86-64 +// @compilerOptions -lole32 -loleaut32 -lruntimeobject -lshlwapi -lwinhttp -lwinmm -lversion -lcomctl32 -lgdi32 -ldwmapi +// ==/WindhawkMod== + +// ==WindhawkModReadme== +/* +# PrayerTray + +Shows the next Islamic prayer on the Windows taskbar so you can see it while +you work, without opening another app. Left-click opens today's times +(Fajr, Dhuhr, Asr, Maghrib, Isha). Works on Windows 10 and 11. + +## Location + +Uses Windows Location when it is allowed, otherwise IP geolocation. +You can also set city or coordinates in the mod settings. +Privacy > Location > allow desktop apps if you want Windows Location. + +## Source + +https://github.com/n0tmar/PrayerTray + +## Support + +If you love this, you can support me on Patreon :) +https://www.patreon.com/n0tmar +*/ +// ==/WindhawkModReadme== + +// ==WindhawkModSettings== +/* +- showOnTaskbar: true + $name: Show on taskbar + $description: Show prayer text beside the clock +- showNotificationIcon: false + $name: Notification icon + $description: Optional icon in the notification area +- playPrayerNotification: false + $name: Prayer notification sound + $description: Soft Allahu Akbar clip 1 minute before prayer time; plays a preview when enabled +- useManualLocation: false + $name: Manual location + $description: Ignore auto location and use the fields below +- manualCity: "" + $name: City + $description: Used when manual location is on +- manualCountry: "" + $name: Country + $description: Used when manual location is on +- manualLatitude: "" + $name: Latitude + $description: Optional decimals; more precise than city alone +- manualLongitude: "" + $name: Longitude + $description: Optional decimals; more precise than city alone +- calculationMethod: 0 + $name: Calculation method + $description: Leave at 0 for your country's default. Advanced users can set an Aladhan method number. +- taskbarContentMode: smart + $name: Taskbar text + $description: Countdown, prayer clock time, or auto + $options: + - countdown: Countdown + - time: Prayer time + - smart: Auto +- timeFormat: 12h + $name: Time format + $description: 12-hour or 24-hour + $options: + - 12h: 12-hour + - 24h: 24-hour +- language: en + $name: Language + $description: Prayer names and labels + $options: + - en: English + - ar: Arabic + - fr: French + - ur: Urdu + - tr: Turkish + - id: Indonesian +- oldTaskbarOnWin11: false + $name: Old taskbar on Windows 11 + $description: Use the Win10-style overlay (ExplorerPatcher) +*/ +// ==/WindhawkModSettings== + +#ifndef WH_MOD_ID +#define WH_MOD_ID L"prayertray" +#endif + +#ifndef WH_MOD_VERSION +#define WH_MOD_VERSION L"2.0.8" +#endif + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#undef GetCurrentTime + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace winrt::Windows::UI::Xaml; + +namespace { + +constexpr wchar_t kColonRatio = L'\u2236'; +constexpr wchar_t kLre = L'\u202A'; +constexpr wchar_t kPdf = L'\u202C'; +constexpr int kNotificationLeadMinutes = 1; +constexpr int kCurrentPrayerHighlightMinutes = 2; +constexpr int kCacheStaleHours = 6; +constexpr double kClusterDistanceKm = 80.0; + +enum class PrayerName { Fajr, Dhuhr, Asr, Maghrib, Isha, Count }; + +enum class TaskbarBackend { Win11Xaml, Win10Overlay }; + +enum class ContentMode { Countdown, Time, Smart }; + +struct ModSettings { + bool showOnTaskbar = true; + bool showNotificationIcon = false; + bool playPrayerNotification = false; + bool useManualLocation = false; + std::wstring manualCity; + std::wstring manualCountry; + std::wstring manualLatitude; + std::wstring manualLongitude; + int calculationMethod = 0; + ContentMode contentMode = ContentMode::Smart; + bool use24Hour = false; + std::wstring language = L"en"; + bool oldTaskbarOnWin11 = false; +}; + +struct LocationInfo { + double latitude = 0; + double longitude = 0; + std::wstring city; + std::wstring region; + std::wstring country; + std::wstring timezone; + std::wstring source = L"ip"; + ULONGLONG resolvedAtUtcMs = 0; +}; + +struct PrayerEntry { + PrayerName name = PrayerName::Fajr; + SYSTEMTIME time{}; + bool isNext = false; + bool isCurrent = false; +}; + +struct PrayerSchedule { + int year = 0; + int month = 0; + int day = 0; + LocationInfo location; + std::vector prayers; + ULONGLONG fetchedAtUtcMs = 0; +}; + +struct NextPrayerInfo { + PrayerName name = PrayerName::Fajr; + SYSTEMTIME time{}; + ULONGLONG secondsUntil = 0; +}; + +struct DisplayContent { + bool visible = false; + std::wstring top; + std::wstring bottom; + std::wstring color = L"FFFFFF"; +}; + +struct IpCandidate { + std::wstring provider; + int weight = 0; + double latitude = 0; + double longitude = 0; + std::wstring city; + std::wstring region; + std::wstring country; + std::wstring timezone; +}; + +ModSettings g_settings; +std::mutex g_scheduleMutex; +LocationInfo g_location; +PrayerSchedule g_currentSchedule; +PrayerSchedule g_nextSchedule; +bool g_hasCurrentSchedule = false; +bool g_hasNextSchedule = false; +std::atomic g_unloading{false}; +std::atomic g_refreshRequested{true}; +std::atomic g_refreshRunning{false}; +std::atomic g_forceLocationRefresh{false}; +std::atomic g_lastRefreshFailed{false}; +std::atomic g_isFullscreen{false}; +std::atomic g_backend{TaskbarBackend::Win11Xaml}; +std::atomic g_isWin11{false}; +std::atomic g_uiTimerIntervalMs{500}; + +HWND g_messageHwnd = nullptr; +UINT_PTR g_uiTimer = 0; +UINT_PTR g_repositionTimer = 0; +UINT_PTR g_fullscreenTimer = 0; +HWND g_win10OverlayHwnd = nullptr; +HWND g_flyoutHwnd = nullptr; +bool g_flyoutVisible = false; +HHOOK g_flyoutMouseHook = nullptr; +ULONGLONG g_flyoutSuppressDismissUntil = 0; +NOTIFYICONDATAW g_trayIcon{}; +bool g_trayIconAdded = false; +HMENU g_contextMenu = nullptr; + +std::unordered_set g_playedNotificationKeys; +int g_notificationActiveDateKey = 0; + +std::atomic g_taskbarViewDllLoaded; +std::atomic g_slotInjected; +std::atomic g_applySlotAttempts; +std::atomic g_injectRetryMs{400}; +std::atomic g_lastMeasureInjectAttemptMs{0}; +int g_lastUiTimerIntervalMs = -1; +bool g_hasOverlayPlacement = false; +int g_lastOverlayX = 0; +int g_lastOverlayY = 0; +int g_lastOverlayW = 0; +int g_lastOverlayH = 0; +bool g_lastOverlayShown = false; +using FrameworkElementLoadedEventRevoker = winrt::impl::event_revoker< + IFrameworkElement, &winrt::impl::abi::type::remove_Loaded>; +std::list g_loadedRevokers; +std::list> g_observedElements; +Controls::TextBlock g_topTextBlock{nullptr}; +Controls::TextBlock g_bottomTextBlock{nullptr}; +Controls::Button g_slotButton{nullptr}; +FrameworkElement g_slotRoot{nullptr}; +Controls::Grid g_slotParentGrid{nullptr}; +std::atomic g_slotPointerOver; +std::atomic g_slotPointerPressed; +std::atomic g_lastCommandId; +std::atomic g_lastCommandTick; +bool g_hasAppliedContent; +bool g_lastAppliedVisible; +std::wstring g_lastAppliedTop; +std::wstring g_lastAppliedBottom; +std::wstring g_lastAppliedColor; + +constexpr int kCmdShowFlyout = 1; +constexpr int kCmdShowMenu = 2; +constexpr int kCmdRefreshLocation = 3; +constexpr int kCmdToggleWidget = 4; +constexpr UINT WM_PT_REFRESH = WM_APP + 1; +constexpr UINT WM_PT_UI_TICK = WM_APP + 2; +constexpr UINT WM_PT_HIDE_FLYOUT = WM_APP + 3; + + +typedef LONG(WINAPI* RtlGetVersion_t)(PRTL_OSVERSIONINFOW); + +bool DetectWin11() { + HMODULE ntdll = GetModuleHandleW(L"ntdll.dll"); + if (!ntdll) { + return false; + } + auto rtlGetVersion = + reinterpret_cast(GetProcAddress(ntdll, "RtlGetVersion")); + if (!rtlGetVersion) { + return false; + } + RTL_OSVERSIONINFOW info{}; + info.dwOSVersionInfoSize = sizeof(info); + if (rtlGetVersion(&info) != 0) { + return false; + } + Wh_Log(L"OS %u.%u build %u", info.dwMajorVersion, info.dwMinorVersion, + info.dwBuildNumber); + return info.dwMajorVersion >= 10 && info.dwBuildNumber >= 22000; +} + +ULONGLONG GetUtcNowMs() { + FILETIME ft{}; + GetSystemTimeAsFileTime(&ft); + ULARGE_INTEGER uli{}; + uli.LowPart = ft.dwLowDateTime; + uli.HighPart = ft.dwHighDateTime; + return uli.QuadPart / 10000; +} + +SYSTEMTIME GetLocalNow() { + SYSTEMTIME st{}; + GetLocalTime(&st); + return st; +} + +int DateKey(const SYSTEMTIME& st) { + return st.wYear * 10000 + st.wMonth * 100 + st.wDay; +} + +int DateKey(int y, int m, int d) { + return y * 10000 + m * 100 + d; +} + +bool SameDate(const SYSTEMTIME& a, int y, int m, int d) { + return a.wYear == y && a.wMonth == m && a.wDay == d; +} + +ULONGLONG SystemTimeToUnixSeconds(const SYSTEMTIME& st) { + SYSTEMTIME utc{}; + TzSpecificLocalTimeToSystemTime(nullptr, &st, &utc); + FILETIME ft{}; + SystemTimeToFileTime(&utc, &ft); + ULARGE_INTEGER uli{}; + uli.LowPart = ft.dwLowDateTime; + uli.HighPart = ft.dwHighDateTime; + return (uli.QuadPart - 116444736000000000ULL) / 10000000ULL; +} + +ULONGLONG LocalNowUnixSeconds() { + SYSTEMTIME now = GetLocalNow(); + return SystemTimeToUnixSeconds(now); +} + +ULONGLONG PrayerUnixSeconds(const PrayerEntry& prayer) { + return SystemTimeToUnixSeconds(prayer.time); +} + +std::wstring Utf8ToWide(std::string_view value) { + if (value.empty()) { + return {}; + } + int size = MultiByteToWideChar(CP_UTF8, 0, value.data(), + static_cast(value.size()), nullptr, 0); + if (size <= 0) { + std::wstring fallback; + fallback.reserve(value.size()); + for (unsigned char ch : value) { + fallback.push_back(static_cast(ch)); + } + return fallback; + } + std::wstring result(size, L'\0'); + MultiByteToWideChar(CP_UTF8, 0, value.data(), + static_cast(value.size()), result.data(), size); + return result; +} + +std::string WideToUtf8(std::wstring_view value) { + if (value.empty()) { + return {}; + } + int size = WideCharToMultiByte(CP_UTF8, 0, value.data(), + static_cast(value.size()), nullptr, 0, + nullptr, nullptr); + if (size <= 0) { + return {}; + } + std::string result(size, '\0'); + WideCharToMultiByte(CP_UTF8, 0, value.data(), + static_cast(value.size()), result.data(), size, + nullptr, nullptr); + return result; +} + +std::wstring Trim(std::wstring s) { + auto notSpace = [](wchar_t c) { return !iswspace(c); }; + s.erase(s.begin(), std::find_if(s.begin(), s.end(), notSpace)); + s.erase(std::find_if(s.rbegin(), s.rend(), notSpace).base(), s.end()); + return s; +} + +std::wstring ToUpper(std::wstring s) { + std::transform(s.begin(), s.end(), s.begin(), towupper); + return s; +} + +std::wstring NormalizeCountry(std::wstring country) { + country = Trim(country); + std::wstring result; + result.reserve(country.size()); + for (wchar_t ch : country) { + if (ch >= 0x0300 && ch <= 0x036F) { + continue; + } + result.push_back(ch); + } + return ToUpper(result); +} + +std::wstring GetAppDataPrayerTrayPath() { + wchar_t appData[MAX_PATH]{}; + DWORD len = GetEnvironmentVariableW(L"APPDATA", appData, MAX_PATH); + if (len == 0 || len >= MAX_PATH) { + return L""; + } + return std::wstring(appData) + L"\\PrayerTray"; +} + +std::wstring GetCacheFolder() { + auto base = GetAppDataPrayerTrayPath(); + if (base.empty()) { + return L""; + } + std::wstring path = base + L"\\cache"; + CreateDirectoryW(base.c_str(), nullptr); + CreateDirectoryW(path.c_str(), nullptr); + return path; +} + +std::wstring SanitizeCachePart(std::wstring value) { + value = Trim(value); + std::wstring out; + out.reserve(value.size()); + for (wchar_t ch : value) { + if (ch == L'<' || ch == L'>' || ch == L':' || ch == L'"' || + ch == L'/' || ch == L'\\' || ch == L'|' || ch == L'?' || + ch == L'*' || iswspace(ch)) { + out.push_back(L'_'); + } else { + out.push_back(ch); + } + } + return out.empty() ? L"unknown" : out; +} + +std::wstring UrlEncodeUtf8(std::string_view value) { + std::wstring encoded; + for (unsigned char ch : value) { + if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || + (ch >= '0' && ch <= '9') || ch == '-' || ch == '_' || + ch == '.' || ch == '~') { + encoded.push_back(static_cast(ch)); + } else { + wchar_t buf[8]; + swprintf(buf, 8, L"%%%02X", ch); + encoded += buf; + } + } + return encoded; +} + +std::wstring UrlEncode(const std::wstring& value) { + return UrlEncodeUtf8(WideToUtf8(value)); +} + +bool ParseDouble(const std::wstring& text, double& out) { + wchar_t* end = nullptr; + out = wcstod(text.c_str(), &end); + return end && end != text.c_str(); +} + +ContentMode ParseContentMode(const std::wstring& mode) { + if (mode == L"time") { + return ContentMode::Time; + } + if (mode == L"countdown") { + return ContentMode::Countdown; + } + return ContentMode::Smart; +} + +void LoadSettings() { + auto takeString = [](PCWSTR key) -> std::wstring { + PCWSTR value = Wh_GetStringSetting(key); + std::wstring result = value ? value : L""; + if (value) { + Wh_FreeStringSetting(value); + } + return result; + }; + + ModSettings s; + s.showOnTaskbar = Wh_GetIntSetting(L"showOnTaskbar") != 0; + s.showNotificationIcon = Wh_GetIntSetting(L"showNotificationIcon") != 0; + s.playPrayerNotification = Wh_GetIntSetting(L"playPrayerNotification") != 0; + s.useManualLocation = Wh_GetIntSetting(L"useManualLocation") != 0; + s.manualCity = takeString(L"manualCity"); + s.manualCountry = takeString(L"manualCountry"); + s.manualLatitude = takeString(L"manualLatitude"); + s.manualLongitude = takeString(L"manualLongitude"); + s.calculationMethod = static_cast(Wh_GetIntSetting(L"calculationMethod")); + s.contentMode = ParseContentMode(takeString(L"taskbarContentMode")); + s.use24Hour = takeString(L"timeFormat") == L"24h"; + s.language = takeString(L"language"); + if (s.language.empty()) { + s.language = L"en"; + } + s.oldTaskbarOnWin11 = Wh_GetIntSetting(L"oldTaskbarOnWin11") != 0; + g_settings = std::move(s); +} + +bool IsRtlLanguage() { + return g_settings.language == L"ar" || g_settings.language == L"ur"; +} + +bool IsLightTheme() { + HKEY key = nullptr; + if (RegOpenKeyExW(HKEY_CURRENT_USER, + L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", + 0, KEY_READ, &key) != ERROR_SUCCESS) { + return false; + } + DWORD value = 0; + DWORD size = sizeof(value); + RegQueryValueExW(key, L"AppsUseLightTheme", nullptr, nullptr, + reinterpret_cast(&value), &size); + RegCloseKey(key); + return value == 1; +} + +std::wstring TaskbarTextColorHex() { + return IsLightTheme() ? L"1A1A1A" : L"FFFFFF"; +} + + +using LocTable = std::unordered_map; + +const LocTable& GetLocTable() { + static const std::unordered_map all = { + {L"en", + {{L"Prayer", L"Prayer"}, {L"Unavailable", L"Unavailable"}, + {L"UnknownLocation", L"Unknown location"}, {L"Detecting", L"Detecting..."}, + {L"TimePeriod_AM", L"AM"}, {L"TimePeriod_PM", L"PM"}, + {L"Prayer_Fajr", L"Fajr"}, {L"Prayer_Dhuhr", L"Dhuhr"}, + {L"Prayer_Asr", L"Asr"}, {L"Prayer_Maghrib", L"Maghrib"}, + {L"Prayer_Isha", L"Isha"}, {L"Tray_TodaySchedule", L"Today's schedule"}, + {L"Tray_RefreshLocation", L"Refresh location"}, + {L"Tray_Settings", L"Open Windhawk"}, + {L"Tray_ShowWidget", L"Show taskbar item"}, + {L"Tray_HideWidget", L"Hide taskbar item"}, + {L"PrayerTimes", L"Prayer times"}, {L"Location_Format", L"Location: {0}"}, + {L"Countdown_Seconds", L"{0}s"}, {L"Countdown_Minutes", L"{0}m"}, + {L"Countdown_Hours", L"{0}h"}, {L"Countdown_HoursMinutes", L"{0}h {1}m"}}}, + {L"ar", + {{L"Prayer", L"صلاة"}, {L"Unavailable", L"غير متاح"}, + {L"UnknownLocation", L"موقع غير معروف"}, {L"Detecting", L"جارٍ تحديد الموقع..."}, + {L"TimePeriod_AM", L"ص"}, {L"TimePeriod_PM", L"م"}, + {L"Prayer_Fajr", L"الفجر"}, {L"Prayer_Dhuhr", L"الظهر"}, + {L"Prayer_Asr", L"العصر"}, {L"Prayer_Maghrib", L"المغرب"}, + {L"Prayer_Isha", L"العشاء"}, {L"Tray_TodaySchedule", L"جدول اليوم"}, + {L"Tray_RefreshLocation", L"تحديث الموقع"}, + {L"Tray_Settings", L"فتح Windhawk"}, + {L"Tray_ShowWidget", L"إظهار عنصر شريط المهام"}, + {L"Tray_HideWidget", L"إخفاء عنصر شريط المهام"}, + {L"PrayerTimes", L"مواقيت الصلاة"}, {L"Location_Format", L"الموقع: {0}"}, + {L"Countdown_Seconds", L"{0} ث"}, {L"Countdown_Minutes", L"{0} د"}, + {L"Countdown_Hours", L"{0} س"}, {L"Countdown_HoursMinutes", L"{0} س {1} د"}}}, + {L"fr", + {{L"Prayer", L"Prière"}, {L"Unavailable", L"Indisponible"}, + {L"UnknownLocation", L"Position inconnue"}, + {L"Detecting", L"Recherche de la position..."}, + {L"TimePeriod_AM", L"AM"}, {L"TimePeriod_PM", L"PM"}, + {L"Prayer_Fajr", L"Fajr"}, {L"Prayer_Dhuhr", L"Dhuhr"}, + {L"Prayer_Asr", L"Asr"}, {L"Prayer_Maghrib", L"Maghrib"}, + {L"Prayer_Isha", L"Isha"}, {L"Tray_TodaySchedule", L"Horaire du jour"}, + {L"Tray_RefreshLocation", L"Actualiser la position"}, + {L"Tray_Settings", L"Ouvrir Windhawk"}, + {L"Tray_ShowWidget", L"Afficher dans la barre des tâches"}, + {L"Tray_HideWidget", L"Masquer dans la barre des tâches"}, + {L"PrayerTimes", L"Horaires de prière"}, {L"Location_Format", L"Position : {0}"}, + {L"Countdown_Seconds", L"{0}s"}, {L"Countdown_Minutes", L"{0}m"}, + {L"Countdown_Hours", L"{0}h"}, {L"Countdown_HoursMinutes", L"{0}h {1}m"}}}, + {L"ur", + {{L"Prayer", L"نماز"}, {L"Unavailable", L"دستیاب نہیں"}, + {L"UnknownLocation", L"نامعلوم مقام"}, {L"Detecting", L"مقام تلاش ہو رہا ہے..."}, + {L"TimePeriod_AM", L"ق.ظ"}, {L"TimePeriod_PM", L"ب.ظ"}, + {L"Prayer_Fajr", L"فجر"}, {L"Prayer_Dhuhr", L"ظہر"}, + {L"Prayer_Asr", L"عصر"}, {L"Prayer_Maghrib", L"مغرب"}, + {L"Prayer_Isha", L"عشاء"}, {L"Tray_TodaySchedule", L"آج کا شیڈول"}, + {L"Tray_RefreshLocation", L"مقام تازہ کریں"}, + {L"Tray_Settings", L"Windhawk کھولیں"}, + {L"Tray_ShowWidget", L"ٹاسک بار آئٹم دکھائیں"}, + {L"Tray_HideWidget", L"ٹاسک بار آئٹم چھپائیں"}, + {L"PrayerTimes", L"نماز کے اوقات"}, {L"Location_Format", L"مقام: {0}"}, + {L"Countdown_Seconds", L"{0} س"}, {L"Countdown_Minutes", L"{0} م"}, + {L"Countdown_Hours", L"{0} گ"}, {L"Countdown_HoursMinutes", L"{0} گ {1} م"}}}, + {L"tr", + {{L"Prayer", L"Namaz"}, {L"Unavailable", L"Kullanılamıyor"}, + {L"UnknownLocation", L"Bilinmeyen konum"}, {L"Detecting", L"Konum aranıyor..."}, + {L"TimePeriod_AM", L"ÖÖ"}, {L"TimePeriod_PM", L"ÖS"}, + {L"Prayer_Fajr", L"İmsak"}, {L"Prayer_Dhuhr", L"Öğle"}, + {L"Prayer_Asr", L"İkindi"}, {L"Prayer_Maghrib", L"Akşam"}, + {L"Prayer_Isha", L"Yatsı"}, {L"Tray_TodaySchedule", L"Bugünün programı"}, + {L"Tray_RefreshLocation", L"Konumu yenile"}, + {L"Tray_Settings", L"Windhawk'ı aç"}, + {L"Tray_ShowWidget", L"Görev çubuğu öğesini göster"}, + {L"Tray_HideWidget", L"Görev çubuğu öğesini gizle"}, + {L"PrayerTimes", L"Namaz vakitleri"}, {L"Location_Format", L"Konum: {0}"}, + {L"Countdown_Seconds", L"{0} sn"}, {L"Countdown_Minutes", L"{0} dk"}, + {L"Countdown_Hours", L"{0} sa"}, {L"Countdown_HoursMinutes", L"{0} sa {1} dk"}}}, + {L"id", + {{L"Prayer", L"Shalat"}, {L"Unavailable", L"Tidak tersedia"}, + {L"UnknownLocation", L"Lokasi tidak diketahui"}, + {L"Detecting", L"Mencari lokasi..."}, + {L"TimePeriod_AM", L"AM"}, {L"TimePeriod_PM", L"PM"}, + {L"Prayer_Fajr", L"Subuh"}, {L"Prayer_Dhuhr", L"Dzuhur"}, + {L"Prayer_Asr", L"Ashar"}, {L"Prayer_Maghrib", L"Maghrib"}, + {L"Prayer_Isha", L"Isya"}, {L"Tray_TodaySchedule", L"Jadwal hari ini"}, + {L"Tray_RefreshLocation", L"Segarkan lokasi"}, + {L"Tray_Settings", L"Buka Windhawk"}, + {L"Tray_ShowWidget", L"Tampilkan item bilah tugas"}, + {L"Tray_HideWidget", L"Sembunyikan item bilah tugas"}, + {L"PrayerTimes", L"Jadwal shalat"}, {L"Location_Format", L"Lokasi: {0}"}, + {L"Countdown_Seconds", L"{0} d"}, {L"Countdown_Minutes", L"{0} m"}, + {L"Countdown_Hours", L"{0} j"}, {L"Countdown_HoursMinutes", L"{0} j {1} m"}}}, + }; + std::wstring lang = g_settings.language; + for (auto& ch : lang) { + if (ch >= L'A' && ch <= L'Z') { + ch = static_cast(ch - L'A' + L'a'); + } + } + auto it = all.find(lang); + if (it != all.end()) { + return it->second; + } + return all.at(L"en"); +} + +std::wstring Loc(const std::wstring& key) { + const auto& table = GetLocTable(); + auto it = table.find(key); + return it != table.end() ? it->second : key; +} + +std::wstring LocFormat(const std::wstring& key, int a, int b = 0) { + std::wstring fmt = Loc(key); + size_t pos = fmt.find(L"{0}"); + if (pos != std::wstring::npos) { + fmt.replace(pos, 3, std::to_wstring(a)); + } + pos = fmt.find(L"{1}"); + if (pos != std::wstring::npos) { + fmt.replace(pos, 3, std::to_wstring(b)); + } + return fmt; +} + +const wchar_t* PrayerNameKey(PrayerName name) { + switch (name) { + case PrayerName::Fajr: + return L"Prayer_Fajr"; + case PrayerName::Dhuhr: + return L"Prayer_Dhuhr"; + case PrayerName::Asr: + return L"Prayer_Asr"; + case PrayerName::Maghrib: + return L"Prayer_Maghrib"; + case PrayerName::Isha: + return L"Prayer_Isha"; + default: + return L"Prayer"; + } +} + +const wchar_t* PrayerApiKey(PrayerName name) { + switch (name) { + case PrayerName::Fajr: + return L"Fajr"; + case PrayerName::Dhuhr: + return L"Dhuhr"; + case PrayerName::Asr: + return L"Asr"; + case PrayerName::Maghrib: + return L"Maghrib"; + case PrayerName::Isha: + return L"Isha"; + default: + return L""; + } +} + +std::wstring GetPrayerName(PrayerName name) { + return Loc(PrayerNameKey(name)); +} + +std::wstring StabilizeCompactText(const std::wstring& text) { + if (IsRtlLanguage()) { + return std::wstring(1, kLre) + text + kPdf; + } + return text; +} + +std::wstring FormatTime(const SYSTEMTIME& time) { + std::wstring text; + if (g_settings.use24Hour) { + wchar_t buf[16]; + swprintf(buf, 16, L"%02u%c%02u", time.wHour, kColonRatio, time.wMinute); + text = buf; + } else { + int hour = time.wHour % 12; + if (hour == 0) { + hour = 12; + } + const std::wstring period = + time.wHour < 12 ? Loc(L"TimePeriod_AM") : Loc(L"TimePeriod_PM"); + wchar_t buf[32]; + // Arabic/Urdu: period on the left of the digits (ص 4:21), not 4:21 ص. + if (IsRtlLanguage()) { + swprintf(buf, 32, L"%s %d%c%02u", period.c_str(), hour, kColonRatio, + time.wMinute); + } else { + swprintf(buf, 32, L"%d%c%02u %s", hour, kColonRatio, time.wMinute, + period.c_str()); + } + text = buf; + } + return StabilizeCompactText(text); +} + +std::wstring FormatCountdown(ULONGLONG seconds) { + std::wstring text; + if (seconds < 60) { + int sec = static_cast(seconds); + text = LocFormat(L"Countdown_Seconds", sec); + } else if (seconds < 3600) { + text = LocFormat(L"Countdown_Minutes", static_cast(seconds / 60)); + } else { + int hours = static_cast(seconds / 3600); + int mins = static_cast((seconds % 3600) / 60); + text = mins == 0 ? LocFormat(L"Countdown_Hours", hours) + : LocFormat(L"Countdown_HoursMinutes", hours, mins); + } + return StabilizeCompactText(text); +} + +std::wstring LocationDisplayName(const LocationInfo& loc) { + if (!loc.city.empty() && !loc.country.empty()) { + return loc.city + L", " + loc.country; + } + if (!loc.city.empty()) { + return loc.city; + } + if (!loc.country.empty()) { + return loc.country; + } + if (!loc.region.empty()) { + return loc.region; + } + return Loc(L"UnknownLocation"); +} + + +std::optional HttpGetUtf8(const std::wstring& url, bool useHttps = true) { + URL_COMPONENTS uc{}; + uc.dwStructSize = sizeof(uc); + wchar_t host[256]{}; + wchar_t path[2048]{}; + wchar_t extra[1024]{}; + uc.lpszHostName = host; + uc.dwHostNameLength = ARRAYSIZE(host); + uc.lpszUrlPath = path; + uc.dwUrlPathLength = ARRAYSIZE(path); + uc.lpszExtraInfo = extra; + uc.dwExtraInfoLength = ARRAYSIZE(extra); + if (!WinHttpCrackUrl(url.c_str(), 0, 0, &uc)) { + return std::nullopt; + } + const bool https = useHttps || uc.nScheme == INTERNET_SCHEME_HTTPS; + HINTERNET session = + WinHttpOpen(L"PrayerTray/2.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, + WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0); + if (!session) { + return std::nullopt; + } + WinHttpSetTimeouts(session, 2000, 2000, 4000, 4000); + HINTERNET connect = WinHttpConnect(session, host, uc.nPort, 0); + if (!connect) { + WinHttpCloseHandle(session); + return std::nullopt; + } + std::wstring objectName = std::wstring(path) + extra; + DWORD flags = https ? WINHTTP_FLAG_SECURE : 0; + HINTERNET request = WinHttpOpenRequest( + connect, L"GET", objectName.c_str(), nullptr, WINHTTP_NO_REFERER, + WINHTTP_DEFAULT_ACCEPT_TYPES, flags); + if (!request) { + WinHttpCloseHandle(connect); + WinHttpCloseHandle(session); + return std::nullopt; + } + if (!WinHttpSendRequest(request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, + WINHTTP_NO_REQUEST_DATA, 0, 0, 0) || + !WinHttpReceiveResponse(request, nullptr)) { + WinHttpCloseHandle(request); + WinHttpCloseHandle(connect); + WinHttpCloseHandle(session); + return std::nullopt; + } + std::string body; + DWORD available = 0; + do { + if (!WinHttpQueryDataAvailable(request, &available)) { + break; + } + if (available == 0) { + break; + } + size_t offset = body.size(); + body.resize(offset + available); + DWORD read = 0; + if (!WinHttpReadData(request, body.data() + offset, available, &read)) { + body.resize(offset); + break; + } + body.resize(offset + read); + } while (available > 0); + WinHttpCloseHandle(request); + WinHttpCloseHandle(connect); + WinHttpCloseHandle(session); + return body.empty() ? std::nullopt : std::optional{std::move(body)}; +} + +std::optional JsonFindValue(std::string_view json, + std::string_view key) { + std::string needle = std::string("\"") + std::string(key) + "\":"; + size_t pos = json.find(needle); + if (pos == std::string_view::npos) { + return std::nullopt; + } + pos += needle.size(); + while (pos < json.size() && (json[pos] == ' ' || json[pos] == '\t')) { + ++pos; + } + if (pos >= json.size()) { + return std::nullopt; + } + if (json[pos] == '"') { + ++pos; + size_t end = pos; + while (end < json.size() && json[end] != '"') { + if (json[end] == '\\' && end + 1 < json.size()) { + end += 2; + } else { + ++end; + } + } + return json.substr(pos, end - pos); + } + size_t end = pos; + while (end < json.size() && json[end] != ',' && json[end] != '}' && + json[end] != ']') { + ++end; + } + return json.substr(pos, end - pos); +} + +std::optional JsonGetDouble(std::string_view json, std::string_view key) { + if (auto val = JsonFindValue(json, key)) { + try { + return std::stod(std::string(*val)); + } catch (...) { + } + } + return std::nullopt; +} + +std::wstring JsonGetStringW(std::string_view json, std::string_view key) { + if (auto val = JsonFindValue(json, key)) { + return Utf8ToWide(*val); + } + return L""; +} + +std::optional JsonFindObject(std::string_view json, + std::string_view key) { + std::string needle = std::string("\"") + std::string(key) + "\":"; + size_t pos = json.find(needle); + if (pos == std::string_view::npos) { + return std::nullopt; + } + pos += needle.size(); + while (pos < json.size() && json[pos] != '{') { + ++pos; + } + if (pos >= json.size()) { + return std::nullopt; + } + int depth = 0; + size_t start = pos; + for (; pos < json.size(); ++pos) { + if (json[pos] == '{') { + ++depth; + } else if (json[pos] == '}') { + --depth; + if (depth == 0) { + return json.substr(start, pos - start + 1); + } + } + } + return std::nullopt; +} + +int GetDefaultMethodForCountry(const std::wstring& country) { + const auto n = NormalizeCountry(country); + if (n == L"UNITED STATES" || n == L"USA" || n == L"CANADA") return 2; + if (n == L"SAUDI ARABIA") return 4; + if (n == L"EGYPT") return 5; + if (n == L"IRAN") return 7; + if (n == L"KUWAIT") return 9; + if (n == L"QATAR") return 10; + if (n == L"UNITED ARAB EMIRATES" || n == L"UAE") return 8; + if (n == L"TURKEY" || n == L"TURKIYE") return 13; + if (n == L"INDONESIA") return 20; + if (n == L"MALAYSIA") return 17; + if (n == L"PAKISTAN" || n == L"BANGLADESH" || n == L"INDIA") return 1; + return 3; +} + +std::wstring GetCountryCode(const std::wstring& country) { + const auto n = NormalizeCountry(country); + if (n == L"SAUDI ARABIA") return L"SA"; + if (n == L"UNITED ARAB EMIRATES" || n == L"UAE") return L"AE"; + if (n == L"EGYPT") return L"EG"; + if (n == L"UNITED STATES" || n == L"USA") return L"US"; + if (n == L"UNITED KINGDOM") return L"GB"; + if (n == L"PAKISTAN") return L"PK"; + if (n == L"INDIA") return L"IN"; + if (n == L"TURKEY" || n == L"TURKIYE") return L"TR"; + if (n == L"INDONESIA") return L"ID"; + if (n == L"MALAYSIA") return L"MY"; + if (n == L"KUWAIT") return L"KW"; + if (n == L"QATAR") return L"QA"; + if (n == L"CANADA") return L"CA"; + return L""; +} + +std::wstring GetDefaultTimezoneForCountry(const std::wstring& country) { + const auto n = NormalizeCountry(country); + if (n == L"SAUDI ARABIA") return L"Asia/Riyadh"; + if (n == L"UNITED ARAB EMIRATES" || n == L"UAE") return L"Asia/Dubai"; + if (n == L"EGYPT") return L"Africa/Cairo"; + if (n == L"KUWAIT") return L"Asia/Kuwait"; + if (n == L"QATAR") return L"Asia/Qatar"; + if (n == L"TURKEY" || n == L"TURKIYE") return L"Europe/Istanbul"; + if (n == L"INDONESIA") return L"Asia/Jakarta"; + if (n == L"MALAYSIA") return L"Asia/Kuala_Lumpur"; + if (n == L"PAKISTAN") return L"Asia/Karachi"; + if (n == L"INDIA") return L"Asia/Kolkata"; + return L""; +} + +int ResolveCalculationMethod(const LocationInfo& loc) { + if (g_settings.calculationMethod > 0) { + return g_settings.calculationMethod; + } + return GetDefaultMethodForCountry(loc.country); +} + +double DistanceKm(const IpCandidate& a, const IpCandidate& b) { + const double earthRadiusKm = 6371.0; + auto deg2rad = [](double d) { return d * 3.141592653589793 / 180.0; }; + double lat1 = deg2rad(a.latitude); + double lat2 = deg2rad(b.latitude); + double dLat = deg2rad(b.latitude - a.latitude); + double dLon = deg2rad(b.longitude - a.longitude); + double sinLat = sin(dLat / 2); + double sinLon = sin(dLon / 2); + double h = sinLat * sinLat + cos(lat1) * cos(lat2) * sinLon * sinLon; + return earthRadiusKm * 2 * atan2(sqrt(h), sqrt(1 - h)); +} + +std::optional TryFetchIpApi() { + auto body = HttpGetUtf8(L"http://ip-api.com/json/?fields=status,message,lat,lon,city,regionName,country,timezone", false); + if (!body) return std::nullopt; + if (JsonGetStringW(*body, "status") != L"success") return std::nullopt; + IpCandidate c; + c.provider = L"ip-api"; + c.weight = 2; + c.latitude = JsonGetDouble(*body, "lat").value_or(0); + c.longitude = JsonGetDouble(*body, "lon").value_or(0); + c.city = JsonGetStringW(*body, "city"); + c.region = JsonGetStringW(*body, "regionName"); + c.country = JsonGetStringW(*body, "country"); + c.timezone = JsonGetStringW(*body, "timezone"); + return c; +} + +std::wstring ReadCountryNameFromCode(const std::wstring& code) { + const auto c = ToUpper(code); + if (c == L"SA") return L"Saudi Arabia"; + if (c == L"AE") return L"United Arab Emirates"; + if (c == L"EG") return L"Egypt"; + if (c == L"US") return L"United States"; + if (c == L"GB") return L"United Kingdom"; + if (c == L"PK") return L"Pakistan"; + if (c == L"IN") return L"India"; + if (c == L"TR") return L"Turkey"; + if (c == L"ID") return L"Indonesia"; + if (c == L"MY") return L"Malaysia"; + return code; +} + +std::optional TryFetchIpInfo() { + auto body = HttpGetUtf8(L"https://ipinfo.io/json"); + if (!body) return std::nullopt; + auto loc = JsonGetStringW(*body, "loc"); + if (loc.empty()) return std::nullopt; + auto comma = loc.find(L','); + if (comma == std::wstring::npos) return std::nullopt; + IpCandidate c; + c.provider = L"ipinfo"; + c.weight = 3; + c.latitude = wcstod(loc.c_str(), nullptr); + c.longitude = wcstod(loc.substr(comma + 1).c_str(), nullptr); + c.city = JsonGetStringW(*body, "city"); + c.region = JsonGetStringW(*body, "region"); + c.country = ReadCountryNameFromCode(JsonGetStringW(*body, "country")); + c.timezone = JsonGetStringW(*body, "timezone"); + return c; +} + +std::optional TryFetchIpWho() { + auto body = HttpGetUtf8(L"https://ipwho.is/"); + if (!body) return std::nullopt; + auto success = JsonFindValue(*body, "success"); + if (!success || *success != "true") return std::nullopt; + IpCandidate c; + c.provider = L"ipwho"; + c.weight = 1; + c.latitude = JsonGetDouble(*body, "latitude").value_or(0); + c.longitude = JsonGetDouble(*body, "longitude").value_or(0); + c.city = JsonGetStringW(*body, "city"); + c.region = JsonGetStringW(*body, "region"); + c.country = JsonGetStringW(*body, "country"); + if (auto tzObj = JsonFindObject(*body, "timezone")) { + c.timezone = JsonGetStringW(*tzObj, "id"); + } + return c; +} + +IpCandidate SelectBestCandidate(std::vector& candidates) { + std::vector> clusters; + for (size_t i = 0; i < candidates.size(); ++i) { + bool matched = false; + for (auto& cluster : clusters) { + if (DistanceKm(candidates[i], candidates[cluster[0]]) <= kClusterDistanceKm) { + cluster.push_back(i); + matched = true; + break; + } + } + if (!matched) { + clusters.push_back({i}); + } + } + + auto clusterTightness = [&](const std::vector& cluster) { + double maxDistance = 0; + for (size_t i = 0; i < cluster.size(); ++i) { + for (size_t j = i + 1; j < cluster.size(); ++j) { + maxDistance = (std::max)( + maxDistance, DistanceKm(candidates[cluster[i]], candidates[cluster[j]])); + } + } + return maxDistance; + }; + + auto best = clusters.begin(); + for (auto it = clusters.begin(); it != clusters.end(); ++it) { + if (it->size() > best->size()) { + best = it; + continue; + } + if (it->size() < best->size()) { + continue; + } + const double tightA = clusterTightness(*it); + const double tightB = clusterTightness(*best); + if (tightA < tightB) { + best = it; + continue; + } + if (tightA > tightB) { + continue; + } + int weightA = 0, weightB = 0; + for (size_t idx : *it) weightA += candidates[idx].weight; + for (size_t idx : *best) weightB += candidates[idx].weight; + if (weightA > weightB) best = it; + } + + double lat = 0, lon = 0; + int weight = 0; + std::wstring providers; + const IpCandidate* bestNamed = &candidates[(*best)[0]]; + for (size_t idx : *best) { + lat += candidates[idx].latitude; + lon += candidates[idx].longitude; + weight += candidates[idx].weight; + if (candidates[idx].weight > bestNamed->weight) { + bestNamed = &candidates[idx]; + } + if (!providers.empty()) providers += L"+"; + providers += candidates[idx].provider; + } + lat /= best->size(); + lon /= best->size(); + IpCandidate result; + result.provider = providers; + result.weight = weight; + result.latitude = lat; + result.longitude = lon; + // Prefer reverse-geocode city over IP label. + result.city.clear(); + result.region = bestNamed->region; + result.country = bestNamed->country; + result.timezone = bestNamed->timezone; + return result; +} + +std::optional TryFetchFreeIpApi() { + auto body = HttpGetUtf8(L"https://free.freeipapi.com/api/json"); + if (!body) return std::nullopt; + IpCandidate c; + c.provider = L"freeipapi"; + c.weight = 2; + c.latitude = JsonGetDouble(*body, "latitude").value_or(0); + c.longitude = JsonGetDouble(*body, "longitude").value_or(0); + if (c.latitude == 0 && c.longitude == 0) return std::nullopt; + c.city = JsonGetStringW(*body, "cityName"); + c.region = JsonGetStringW(*body, "regionName"); + c.country = JsonGetStringW(*body, "countryName"); + c.timezone = JsonGetStringW(*body, "timeZones"); + if (c.timezone.empty()) { + if (auto zones = JsonFindObject(*body, "timeZones")) { + (void)zones; + } + // freeipapi may return timeZones as an array; first quoted value is enough. + auto pos = body->find("\"timeZones\""); + if (pos != std::string::npos) { + auto q1 = body->find('"', body->find('[', pos)); + if (q1 != std::string::npos) { + auto q2 = body->find('"', q1 + 1); + if (q2 != std::string::npos) { + c.timezone = Utf8ToWide(body->substr(q1 + 1, q2 - q1 - 1)); + } + } + } + } + return c; +} + +std::optional TryFetchGeoJs() { + auto body = HttpGetUtf8(L"https://get.geojs.io/v1/ip/geo.json"); + if (!body) return std::nullopt; + IpCandidate c; + c.provider = L"geojs"; + c.weight = 3; + c.latitude = JsonGetDouble(*body, "latitude").value_or(0); + c.longitude = JsonGetDouble(*body, "longitude").value_or(0); + if (c.latitude == 0 && c.longitude == 0) { + // geojs sometimes returns strings + auto latStr = JsonGetStringW(*body, "latitude"); + auto lonStr = JsonGetStringW(*body, "longitude"); + double lat = 0, lon = 0; + if (!ParseDouble(latStr, lat) || !ParseDouble(lonStr, lon)) return std::nullopt; + c.latitude = lat; + c.longitude = lon; + } + c.city = JsonGetStringW(*body, "city"); + c.region = JsonGetStringW(*body, "region"); + c.country = JsonGetStringW(*body, "country"); + return c; +} + +struct ReverseGeocodeResult { + std::wstring city; + std::wstring region; + std::wstring country; + std::wstring timezone; +}; + +std::wstring FixCityName(std::wstring city) { + auto upper = ToUpper(city); + if (upper == L"MAKKAH" || upper == L"MAKKAH AL MUKARRAMAH" || + upper == L"MECCA" || upper == L"MEKKAH") { + return L"Mecca"; + } + if (upper == L"AL TAIF" || upper == L"AT TAIF" || upper == L"TA'IF") { + return L"Taif"; + } + return city; +} + +std::optional TryReverseGeocode(double latitude, double longitude) { + wchar_t url[512]; + swprintf(url, 512, + L"https://api.bigdatacloud.net/data/reverse-geocode-client?latitude=%.6f&longitude=%.6f&localityLanguage=en", + latitude, longitude); + auto body = HttpGetUtf8(url); + if (!body) return std::nullopt; + + ReverseGeocodeResult result; + result.city = JsonGetStringW(*body, "locality"); + if (result.city.empty()) { + result.city = JsonGetStringW(*body, "city"); + } + result.region = JsonGetStringW(*body, "principalSubdivision"); + result.country = JsonGetStringW(*body, "countryName"); + result.timezone = JsonGetStringW(*body, "ianaTimeId"); + if (result.timezone.empty()) { + result.timezone = JsonGetStringW(*body, "localityInfo"); // ignored if wrong shape + result.timezone.clear(); + } + if (result.city.empty() && result.country.empty()) { + return std::nullopt; + } + result.city = FixCityName(result.city); + return result; +} + +std::wstring FirstNonEmpty(std::initializer_list values) { + for (const auto& value : values) { + if (!Trim(value).empty()) { + return value; + } + } + return L""; +} + +LocationInfo ResolveManualLocation() { + LocationInfo loc; + loc.source = L"manual"; + loc.resolvedAtUtcMs = GetUtcNowMs(); + loc.city = FixCityName(Trim(g_settings.manualCity)); + loc.country = Trim(g_settings.manualCountry); + loc.timezone = GetDefaultTimezoneForCountry(loc.country); + double lat = 0, lon = 0; + if (ParseDouble(g_settings.manualLatitude, lat) && + ParseDouble(g_settings.manualLongitude, lon)) { + loc.latitude = lat; + loc.longitude = lon; + return loc; + } + if (!loc.city.empty() && !loc.country.empty()) { + loc.source = L"manual-city"; + return loc; + } + loc.country = L"Unknown"; + return loc; +} + +std::wstring JsonEscape(const std::wstring& value) { + std::wstring out; + out.reserve(value.size()); + for (wchar_t ch : value) { + if (ch == L'\\' || ch == L'"') { + out.push_back(L'\\'); + out.push_back(ch); + } else if (ch == L'\n') { + out += L"\\n"; + } else { + out.push_back(ch); + } + } + return out; +} + +std::wstring GetLastLocationPath() { + auto base = GetAppDataPrayerTrayPath(); + if (base.empty()) { + return L""; + } + CreateDirectoryW(base.c_str(), nullptr); + return base + L"\\last-location.json"; +} + +void SaveLastLocation(const LocationInfo& loc) { + const auto path = GetLastLocationPath(); + if (path.empty() || (loc.latitude == 0 && loc.longitude == 0 && loc.city.empty())) { + return; + } + std::ofstream out(path.c_str(), std::ios::binary | std::ios::trunc); + if (!out) { + return; + } + out << "{\n"; + out << " \"Latitude\": " << loc.latitude << ",\n"; + out << " \"Longitude\": " << loc.longitude << ",\n"; + out << " \"City\": \"" << WideToUtf8(JsonEscape(loc.city)) << "\",\n"; + out << " \"Region\": \"" << WideToUtf8(JsonEscape(loc.region)) << "\",\n"; + out << " \"Country\": \"" << WideToUtf8(JsonEscape(loc.country)) << "\",\n"; + out << " \"Timezone\": \"" << WideToUtf8(JsonEscape(loc.timezone)) << "\",\n"; + out << " \"Source\": \"" << WideToUtf8(JsonEscape(loc.source)) << "\",\n"; + out << " \"ResolvedAtUtcMs\": " << loc.resolvedAtUtcMs << "\n"; + out << "}\n"; +} + +std::optional LoadLastLocation() { + const auto path = GetLastLocationPath(); + if (path.empty()) { + return std::nullopt; + } + std::ifstream in(path.c_str(), std::ios::binary); + if (!in) { + return std::nullopt; + } + std::string json((std::istreambuf_iterator(in)), std::istreambuf_iterator()); + if (json.empty()) { + return std::nullopt; + } + LocationInfo loc; + loc.latitude = JsonGetDouble(json, "Latitude").value_or(0); + loc.longitude = JsonGetDouble(json, "Longitude").value_or(0); + loc.city = FixCityName(JsonGetStringW(json, "City")); + loc.region = JsonGetStringW(json, "Region"); + loc.country = JsonGetStringW(json, "Country"); + loc.timezone = JsonGetStringW(json, "Timezone"); + loc.source = L"last-known"; + loc.resolvedAtUtcMs = GetUtcNowMs(); + if (loc.latitude == 0 && loc.longitude == 0 && loc.city.empty()) { + return std::nullopt; + } + return loc; +} + +LocationInfo FillFromCoords(LocationInfo loc, + double latitude, + double longitude, + const std::wstring& source, + const std::wstring& fallbackCity = L"", + const std::wstring& fallbackRegion = L"", + const std::wstring& fallbackCountry = L"", + const std::wstring& fallbackTimezone = L"") { + loc.latitude = latitude; + loc.longitude = longitude; + loc.source = source; + loc.resolvedAtUtcMs = GetUtcNowMs(); + + if (auto reverse = TryReverseGeocode(latitude, longitude)) { + loc.city = FirstNonEmpty({reverse->city, fallbackCity}); + loc.region = FirstNonEmpty({reverse->region, fallbackRegion}); + loc.country = FirstNonEmpty({reverse->country, fallbackCountry}); + loc.timezone = FirstNonEmpty({reverse->timezone, fallbackTimezone}); + } else { + loc.city = fallbackCity; + loc.region = fallbackRegion; + loc.country = fallbackCountry; + loc.timezone = fallbackTimezone; + } + if (loc.timezone.empty()) { + loc.timezone = GetDefaultTimezoneForCountry(loc.country); + } + loc.city = FixCityName(loc.city); + return loc; +} + +std::optional TryWindowsLocation() { + try { + using namespace winrt::Windows::Devices::Geolocation; + using namespace winrt::Windows::Foundation; + using namespace std::chrono_literals; + + try { + winrt::init_apartment(winrt::apartment_type::multi_threaded); + } catch (winrt::hresult_error const&) { + } + + const auto access = Geolocator::RequestAccessAsync().get(); + if (access != GeolocationAccessStatus::Allowed) { + Wh_Log(L"Windows Location denied (%d)", + static_cast(access)); + return std::nullopt; + } + + Geolocator locator; + const auto status = locator.LocationStatus(); + if (status == PositionStatus::Disabled || + status == PositionStatus::NotAvailable) { + Wh_Log(L"Windows Location off (%d)", + static_cast(status)); + return std::nullopt; + } + + locator.DesiredAccuracy(PositionAccuracy::Default); + try { + locator.DesiredAccuracyInMeters(1000); + } catch (...) { + } + + const auto position = + locator.GetGeopositionAsync(TimeSpan{30s}, TimeSpan{3s}).get(); + if (!position) { + Wh_Log(L"Windows Location: no fix"); + return std::nullopt; + } + + const auto coord = position.Coordinate().Point().Position(); + if (coord.Latitude == 0 && coord.Longitude == 0) { + Wh_Log(L"Windows Location: empty coords"); + return std::nullopt; + } + + LocationInfo loc = + FillFromCoords({}, coord.Latitude, coord.Longitude, L"windows"); + Wh_Log(L"Location (windows): %s, %s (%.5f, %.5f)", + loc.city.c_str(), loc.country.c_str(), loc.latitude, loc.longitude); + return loc; + } catch (winrt::hresult_error const& ex) { + Wh_Log(L"Windows Location failed: 0x%08X %s", + static_cast(ex.code()), ex.message().c_str()); + return std::nullopt; + } catch (...) { + Wh_Log(L"Windows Location failed"); + return std::nullopt; + } +} + +LocationInfo TryIpLocation() { + Wh_Log(L"Trying IP location"); + std::vector>> jobs; + jobs.push_back(std::async(std::launch::async, TryFetchIpApi)); + jobs.push_back(std::async(std::launch::async, TryFetchIpInfo)); + jobs.push_back(std::async(std::launch::async, TryFetchIpWho)); + jobs.push_back(std::async(std::launch::async, TryFetchFreeIpApi)); + jobs.push_back(std::async(std::launch::async, TryFetchGeoJs)); + + std::vector candidates; + for (auto& job : jobs) { + try { + if (auto c = job.get()) { + candidates.push_back(*c); + } + } catch (...) { + } + } + if (candidates.empty()) { + throw std::runtime_error("all IP providers failed"); + } + auto winner = SelectBestCandidate(candidates); + LocationInfo loc = FillFromCoords( + {}, winner.latitude, winner.longitude, L"ip", winner.city, winner.region, + winner.country, winner.timezone); + Wh_Log(L"Location (ip): %s, %s (%.4f, %.4f) [%s]", + loc.city.c_str(), loc.country.c_str(), loc.latitude, loc.longitude, + winner.provider.c_str()); + return loc; +} + +LocationInfo ResolveLocation() { + if (g_settings.useManualLocation) { + auto loc = ResolveManualLocation(); + SaveLastLocation(loc); + return loc; + } + + // Prefer a known location immediately; refresh can replace it later. + auto cachedLoc = LoadLastLocation(); + + if (auto loc = TryWindowsLocation()) { + SaveLastLocation(*loc); + return *loc; + } + + try { + auto loc = TryIpLocation(); + SaveLastLocation(loc); + return loc; + } catch (const std::exception& ex) { + Wh_Log(L"IP location failed: %S", ex.what()); + } catch (...) { + Wh_Log(L"IP location failed"); + } + + if (cachedLoc) { + Wh_Log(L"Location (cached): %s, %s", cachedLoc->city.c_str(), + cachedLoc->country.c_str()); + return *cachedLoc; + } + + throw std::runtime_error("location unavailable"); +} + +bool ParseTimeOnly(const std::wstring& text, SYSTEMTIME& outDate, SYSTEMTIME& outTime) { + std::wstring clean = text; + auto space = clean.find(L' '); + if (space != std::wstring::npos) { + clean = clean.substr(0, space); + } + auto colon = clean.find(L':'); + if (colon == std::wstring::npos) return false; + outTime = outDate; + outTime.wHour = static_cast(wcstoul(clean.substr(0, colon).c_str(), nullptr, 10)); + outTime.wMinute = static_cast(wcstoul(clean.substr(colon + 1).c_str(), nullptr, 10)); + outTime.wSecond = 0; + outTime.wMilliseconds = 0; + return true; +} + +PrayerSchedule BuildScheduleFromTimingsJson(std::string_view timingsJson, + int year, int month, int day, + LocationInfo location, + const std::wstring& timezone) { + PrayerSchedule schedule; + schedule.year = year; + schedule.month = month; + schedule.day = day; + schedule.location = location; + schedule.fetchedAtUtcMs = GetUtcNowMs(); + if (!timezone.empty()) { + schedule.location.timezone = timezone; + } + SYSTEMTIME date{}; + date.wYear = static_cast(year); + date.wMonth = static_cast(month); + date.wDay = static_cast(day); + for (int i = 0; i < static_cast(PrayerName::Count); ++i) { + auto name = static_cast(i); + std::string key = WideToUtf8(PrayerApiKey(name)); + auto val = JsonFindValue(timingsJson, key); + if (!val) continue; + PrayerEntry entry; + entry.name = name; + if (ParseTimeOnly(Utf8ToWide(*val), date, entry.time)) { + schedule.prayers.push_back(entry); + } + } + return schedule; +} + +std::wstring BuildCachePath(int year, int month, int day, const LocationInfo& loc, + int method) { + std::wstring key; + if (loc.latitude != 0 || loc.longitude != 0) { + wchar_t buf[64]; + swprintf(buf, 64, L"%.4f_%.4f", loc.latitude, loc.longitude); + key = buf; + } else { + key = loc.city + L"_" + loc.country; + } + key = SanitizeCachePart(key); + std::wstring tz = loc.timezone.empty() ? L"notz" : SanitizeCachePart(loc.timezone); + wchar_t path[512]; + swprintf(path, 512, L"%04d-%02d-%02d_%s_m%d_%s.json", year, month, day, + key.c_str(), method, tz.c_str()); + return GetCacheFolder() + L"\\" + path; +} + +std::wstring BuildIslamicAppUrl(int year, int month, int day, const LocationInfo& loc, + int method) { + SYSTEMTIME now = GetLocalNow(); + std::wstring dateSegment; + if (year == now.wYear && month == now.wMonth && day == now.wDay) { + dateSegment = L"today"; + } else { + wchar_t buf[16]; + swprintf(buf, 16, L"%02d-%02d-%04d", day, month, year); + dateSegment = buf; + } + std::wstring url = L"https://api.islamic.app/v1/timings/" + dateSegment + L"?"; + if (loc.source == L"manual-city") { + auto cc = GetCountryCode(loc.country); + url += L"city=" + UrlEncode(loc.city) + L"&country=" + cc + L"&method=" + + std::to_wstring(method); + } else { + url += L"latitude=" + std::to_wstring(loc.latitude) + L"&longitude=" + + std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method); + if (!loc.timezone.empty()) { + url += L"&timezone=" + UrlEncode(loc.timezone); + } + } + return url; +} + +std::wstring BuildAladhanUrl(int year, int month, int day, const LocationInfo& loc, + int method) { + wchar_t dateSeg[16]; + swprintf(dateSeg, 16, L"%02d-%02d-%04d", day, month, year); + std::wstring url; + if (loc.source == L"manual-city") { + url = L"https://api.aladhan.com/v1/timingsByCity/" + std::wstring(dateSeg) + + L"?city=" + UrlEncode(loc.city) + L"&country=" + UrlEncode(loc.country) + + L"&method=" + std::to_wstring(method); + } else { + url = L"https://api.aladhan.com/v1/timings/" + std::wstring(dateSeg) + + L"?latitude=" + std::to_wstring(loc.latitude) + L"&longitude=" + + std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method); + if (!loc.timezone.empty()) { + url += L"&timezonestring=" + UrlEncode(loc.timezone); + } + } + return url; +} + +PrayerSchedule FetchScheduleFromApi(int year, int month, int day, LocationInfo loc) { + int method = ResolveCalculationMethod(loc); + auto parseResponse = [&](const std::string& body) -> PrayerSchedule { + auto data = JsonFindObject(body, "data"); + if (!data) throw std::runtime_error("no data"); + auto timings = JsonFindObject(*data, "timings"); + if (!timings) throw std::runtime_error("no timings"); + std::wstring tz = loc.timezone; + if (auto meta = JsonFindObject(*data, "meta")) { + auto tzVal = JsonGetStringW(*meta, "timezone"); + if (!tzVal.empty()) tz = tzVal; + } + return BuildScheduleFromTimingsJson(*timings, year, month, day, loc, tz); + }; + try { + auto url = BuildIslamicAppUrl(year, month, day, loc, method); + auto body = HttpGetUtf8(url); + if (!body) throw std::runtime_error("islamic.app failed"); + return parseResponse(*body); + } catch (...) { + auto url = BuildAladhanUrl(year, month, day, loc, method); + auto body = HttpGetUtf8(url); + if (!body) throw std::runtime_error("aladhan failed"); + return parseResponse(*body); + } +} + +bool IsCacheStale(const PrayerSchedule& schedule, int y, int m, int d, + const LocationInfo& loc) { + if (schedule.year != y || schedule.month != m || schedule.day != d) return true; + if (!loc.timezone.empty() && !schedule.location.timezone.empty() && + _wcsicmp(loc.timezone.c_str(), schedule.location.timezone.c_str()) != 0) { + return true; + } + SYSTEMTIME now = GetLocalNow(); + if (y == now.wYear && m == now.wMonth && d == now.wDay) { + ULONGLONG ageMs = GetUtcNowMs() - schedule.fetchedAtUtcMs; + return ageMs > static_cast(kCacheStaleHours) * 3600000ULL; + } + return false; +} + +std::optional LoadCache(int year, int month, int day, + const LocationInfo& loc, int method) { + auto path = BuildCachePath(year, month, day, loc, method); + std::ifstream in(path.c_str(), std::ios::binary); + if (!in) return std::nullopt; + std::string json((std::istreambuf_iterator(in)), std::istreambuf_iterator()); + if (json.empty()) return std::nullopt; + PrayerSchedule schedule; + auto dateStr = JsonGetStringW(json, "Date"); + if (!dateStr.empty()) { + schedule.year = _wtoi(dateStr.substr(0, 4).c_str()); + schedule.month = _wtoi(dateStr.substr(5, 2).c_str()); + schedule.day = _wtoi(dateStr.substr(8, 2).c_str()); + } else { + schedule.year = year; + schedule.month = month; + schedule.day = day; + } + schedule.location = loc; + schedule.fetchedAtUtcMs = GetUtcNowMs(); + if (auto locObj = JsonFindObject(json, "Location")) { + schedule.location.city = JsonGetStringW(*locObj, "City"); + schedule.location.country = JsonGetStringW(*locObj, "Country"); + schedule.location.timezone = JsonGetStringW(*locObj, "Timezone"); + schedule.location.latitude = JsonGetDouble(*locObj, "Latitude").value_or(loc.latitude); + schedule.location.longitude = JsonGetDouble(*locObj, "Longitude").value_or(loc.longitude); + } + if (auto prayersArr = json.find("\"Prayers\""); prayersArr != std::string::npos) { + SYSTEMTIME date{}; + date.wYear = static_cast(schedule.year); + date.wMonth = static_cast(schedule.month); + date.wDay = static_cast(schedule.day); + for (int i = 0; i < static_cast(PrayerName::Count); ++i) { + auto name = static_cast(i); + std::string key = "\"Name\":" + std::to_string(static_cast(name)); + (void)key; + } + } + auto timings = JsonFindObject(json, "timings"); + if (timings) { + return BuildScheduleFromTimingsJson(*timings, year, month, day, loc, loc.timezone); + } + for (int i = 0; i < static_cast(PrayerName::Count); ++i) { + auto name = static_cast(i); + std::string search = std::string("\"") + WideToUtf8(PrayerApiKey(name)) + "\""; + if (json.find(search) != std::string::npos) { + return BuildScheduleFromTimingsJson(json, year, month, day, loc, loc.timezone); + } + } + SYSTEMTIME date{}; + date.wYear = static_cast(year); + date.wMonth = static_cast(month); + date.wDay = static_cast(day); + size_t pos = 0; + while ((pos = json.find("\"Name\":", pos)) != std::string::npos) { + pos += 7; + while (pos < json.size() && (json[pos] == ' ' || json[pos] == '"')) ++pos; + int nameIdx = atoi(json.c_str() + pos); + pos = json.find("\"Time\":", pos); + if (pos == std::string::npos) break; + pos += 7; + while (pos < json.size() && json[pos] != '"') ++pos; + if (pos >= json.size()) break; + ++pos; + size_t end = json.find('"', pos); + if (end == std::string::npos) break; + std::wstring timeText = Utf8ToWide(json.substr(pos, end - pos)); + if (timeText.size() >= 16) { + SYSTEMTIME st = date; + st.wHour = static_cast(_wtoi(timeText.substr(11, 2).c_str())); + st.wMinute = static_cast(_wtoi(timeText.substr(14, 2).c_str())); + st.wSecond = 0; + PrayerEntry entry; + entry.name = static_cast(nameIdx); + entry.time = st; + schedule.prayers.push_back(entry); + } + pos = end; + } + if (schedule.prayers.empty()) return std::nullopt; + return schedule; +} + +void SaveCache(const PrayerSchedule& schedule, int method) { + auto path = BuildCachePath(schedule.year, schedule.month, schedule.day, + schedule.location, method); + std::ofstream out(path.c_str(), std::ios::binary | std::ios::trunc); + if (!out) return; + out << "{\n"; + wchar_t dateBuf[16]; + swprintf(dateBuf, 16, L"%04d-%02d-%02d", schedule.year, schedule.month, schedule.day); + out << " \"Date\": \"" << WideToUtf8(dateBuf) << "\",\n"; + out << " \"FetchedAtUtc\": \"" << WideToUtf8(std::to_wstring(schedule.fetchedAtUtcMs)) << "\",\n"; + out << " \"Location\": {\n"; + out << " \"Latitude\": " << schedule.location.latitude << ",\n"; + out << " \"Longitude\": " << schedule.location.longitude << ",\n"; + out << " \"City\": \"" << WideToUtf8(schedule.location.city) << "\",\n"; + out << " \"Country\": \"" << WideToUtf8(schedule.location.country) << "\",\n"; + out << " \"Timezone\": \"" << WideToUtf8(schedule.location.timezone) << "\"\n"; + out << " },\n \"timings\": {\n"; + for (size_t i = 0; i < schedule.prayers.size(); ++i) { + const auto& p = schedule.prayers[i]; + char timeBuf[16]; + snprintf(timeBuf, sizeof(timeBuf), "%02u:%02u:00", p.time.wHour, p.time.wMinute); + out << " \"" << WideToUtf8(PrayerApiKey(p.name)) << "\": \"" << timeBuf << "\""; + if (i + 1 < schedule.prayers.size()) out << ","; + out << "\n"; + } + out << " }\n}\n"; +} + +PrayerSchedule GetScheduleForDate(int year, int month, int day, LocationInfo loc) { + int method = ResolveCalculationMethod(loc); + if (auto cached = LoadCache(year, month, day, loc, method)) { + if (!IsCacheStale(*cached, year, month, day, loc)) { + return *cached; + } + } + auto schedule = FetchScheduleFromApi(year, month, day, loc); + SaveCache(schedule, method); + return schedule; +} + +void AddDays(SYSTEMTIME& st, int days) { + FILETIME ft{}; + SystemTimeToFileTime(&st, &ft); + ULARGE_INTEGER uli{}; + uli.LowPart = ft.dwLowDateTime; + uli.HighPart = ft.dwHighDateTime; + uli.QuadPart += static_cast(days) * 864000000000ULL; + ft.dwLowDateTime = uli.LowPart; + ft.dwHighDateTime = uli.HighPart; + FileTimeToSystemTime(&ft, &st); +} + +std::optional GetNextPrayer() { + std::lock_guard lock(g_scheduleMutex); + if (!g_hasCurrentSchedule) return std::nullopt; + ULONGLONG nowSec = LocalNowUnixSeconds(); + NextPrayerInfo best{}; + ULONGLONG bestSec = 0; + bool found = false; + auto consider = [&](const PrayerSchedule& sched) { + for (const auto& p : sched.prayers) { + ULONGLONG t = PrayerUnixSeconds(p); + if (t >= nowSec) { + if (!found || t < bestSec) { + best.name = p.name; + best.time = p.time; + best.secondsUntil = t - nowSec; + bestSec = t; + found = true; + } + } + } + }; + consider(g_currentSchedule); + if (g_hasNextSchedule) consider(g_nextSchedule); + return found ? std::optional{best} : std::nullopt; +} + +std::vector GetTodayEntriesWithStatus() { + std::lock_guard lock(g_scheduleMutex); + std::vector result; + if (!g_hasCurrentSchedule) return result; + ULONGLONG nowSec = LocalNowUnixSeconds(); + const PrayerEntry* current = nullptr; + for (const auto& p : g_currentSchedule.prayers) { + ULONGLONG t = PrayerUnixSeconds(p); + if (nowSec >= t && + nowSec < t + kCurrentPrayerHighlightMinutes * 60) { + current = &p; + break; + } + } + NextPrayerInfo nextInfo{}; + bool hasNext = false; + auto considerNext = [&](const PrayerSchedule& sched) { + for (const auto& p : sched.prayers) { + ULONGLONG t = PrayerUnixSeconds(p); + if (t >= nowSec) { + if (!hasNext || t < SystemTimeToUnixSeconds(nextInfo.time)) { + nextInfo.name = p.name; + nextInfo.time = p.time; + nextInfo.secondsUntil = t - nowSec; + hasNext = true; + } + } + } + }; + considerNext(g_currentSchedule); + if (g_hasNextSchedule) considerNext(g_nextSchedule); + for (auto p : g_currentSchedule.prayers) { + p.isCurrent = current && current->name == p.name && + current->time.wHour == p.time.wHour && + current->time.wMinute == p.time.wMinute; + if (hasNext && !current) { + p.isNext = p.name == nextInfo.name && + p.time.wHour == nextInfo.time.wHour && + p.time.wMinute == nextInfo.time.wMinute; + } + result.push_back(p); + } + return result; +} + +DisplayContent FormatTaskbarDisplay() { + DisplayContent content; + content.color = TaskbarTextColorHex(); + if (!g_settings.showOnTaskbar || g_isFullscreen.load()) { + content.visible = false; + return content; + } + auto next = GetNextPrayer(); + const bool slotReady = + g_backend.load() != TaskbarBackend::Win11Xaml || g_slotInjected.load(); + if (!next) { + content.visible = true; + if (g_lastRefreshFailed.load() && !g_refreshRunning.load()) { + content.top = StabilizeCompactText(Loc(L"Unavailable")); + content.bottom = Loc(L"Prayer"); + } else { + content.top = StabilizeCompactText(L"..."); + content.bottom = Loc(L"Detecting"); + } + g_uiTimerIntervalMs = slotReady ? 2000 : g_injectRetryMs.load(); + return content; + } + content.visible = true; + content.bottom = GetPrayerName(next->name); + switch (g_settings.contentMode) { + case ContentMode::Time: + content.top = FormatTime(next->time); + break; + case ContentMode::Smart: + if (next->secondsUntil > 3600) { + content.top = FormatTime(next->time); + } else { + content.top = FormatCountdown(next->secondsUntil); + } + break; + default: + content.top = FormatCountdown(next->secondsUntil); + break; + } + int intervalMs = 30000; + if (next->secondsUntil <= 3600) intervalMs = 1000; + else if (next->secondsUntil <= 6 * 3600) intervalMs = 15000; + if (!slotReady) { + intervalMs = g_injectRetryMs.load(); + } + g_uiTimerIntervalMs = intervalMs; + return content; +} + +// BEGIN_EMBEDDED_NOTIFICATION_SOUND +// auto-generated +static const unsigned char kAllahAkbarMp3[] = { + 0x49, 0x44, 0x33, 0x04, 0x00, 0x00, 0x00, 0x00, 0x01, 0x70, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, + 0x00, 0x12, 0x00, 0x00, 0x03, 0x6D, 0x61, 0x6A, 0x6F, 0x72, 0x5F, 0x62, 0x72, 0x61, 0x6E, 0x64, + 0x00, 0x6D, 0x70, 0x34, 0x32, 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, + 0x03, 0x6D, 0x69, 0x6E, 0x6F, 0x72, 0x5F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x00, 0x30, + 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x03, 0x63, 0x6F, 0x6D, 0x70, + 0x61, 0x74, 0x69, 0x62, 0x6C, 0x65, 0x5F, 0x62, 0x72, 0x61, 0x6E, 0x64, 0x73, 0x00, 0x69, 0x73, + 0x6F, 0x6D, 0x6D, 0x70, 0x34, 0x32, 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x26, 0x00, + 0x00, 0x03, 0x63, 0x6F, 0x6D, 0x2E, 0x73, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x61, 0x6E, + 0x64, 0x72, 0x6F, 0x69, 0x64, 0x2E, 0x75, 0x74, 0x63, 0x5F, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, + 0x00, 0x2B, 0x30, 0x33, 0x30, 0x30, 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x18, 0x00, + 0x00, 0x03, 0x63, 0x6F, 0x6D, 0x2E, 0x61, 0x6E, 0x64, 0x72, 0x6F, 0x69, 0x64, 0x2E, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x00, 0x31, 0x35, 0x00, 0x54, 0x50, 0x45, 0x31, 0x00, 0x00, 0x00, + 0x14, 0x00, 0x00, 0x03, 0x20, 0x7C, 0x20, 0x42, 0x79, 0x20, 0x58, 0x39, 0x20, 0x43, 0x6F, 0x6E, + 0x76, 0x65, 0x72, 0x74, 0x65, 0x72, 0x00, 0x54, 0x53, 0x53, 0x45, 0x00, 0x00, 0x00, 0x0F, 0x00, + 0x00, 0x03, 0x4C, 0x61, 0x76, 0x66, 0x36, 0x30, 0x2E, 0x31, 0x36, 0x2E, 0x31, 0x30, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFB, 0x90, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x6E, + 0x66, 0x6F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x01, 0x4D, 0x0E, 0x00, 0x05, + 0x07, 0x0A, 0x0C, 0x0F, 0x11, 0x14, 0x16, 0x19, 0x1B, 0x1E, 0x20, 0x23, 0x25, 0x28, 0x2A, 0x2D, + 0x2F, 0x32, 0x34, 0x37, 0x39, 0x3C, 0x3E, 0x41, 0x43, 0x46, 0x48, 0x4B, 0x4D, 0x50, 0x52, 0x55, + 0x59, 0x5B, 0x5E, 0x60, 0x63, 0x65, 0x68, 0x6A, 0x6D, 0x6F, 0x72, 0x74, 0x77, 0x79, 0x7C, 0x7E, + 0x81, 0x83, 0x86, 0x88, 0x8B, 0x8D, 0x90, 0x92, 0x95, 0x97, 0x9A, 0x9C, 0x9F, 0xA1, 0xA4, 0xA6, + 0xA9, 0xAD, 0xAF, 0xB2, 0xB4, 0xB7, 0xB9, 0xBC, 0xBE, 0xC1, 0xC3, 0xC6, 0xC8, 0xCB, 0xCD, 0xD0, + 0xD2, 0xD5, 0xD7, 0xDA, 0xDC, 0xDF, 0xE1, 0xE4, 0xE6, 0xE9, 0xEB, 0xEE, 0xF0, 0xF3, 0xF5, 0xF8, + 0xFA, 0xFD, 0x00, 0x00, 0x00, 0x00, 0x4C, 0x61, 0x76, 0x63, 0x36, 0x30, 0x2E, 0x33, 0x31, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x03, 0x87, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x4D, 0x0E, 0x77, 0xAF, 0x33, 0xAE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 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, 0xFB, 0x90, 0x64, 0x00, + 0x08, 0x02, 0xFE, 0x3F, 0xB7, 0x9B, 0x06, 0x1A, 0xF0, 0x20, 0x80, 0x17, 0x8C, 0x00, 0x41, 0x00, + 0x0D, 0x69, 0x60, 0xF4, 0xAC, 0x18, 0xB3, 0xC1, 0x3F, 0x25, 0x9E, 0x80, 0xC3, 0x09, 0x78, 0x00, + 0x12, 0x01, 0x50, 0xBF, 0x71, 0xC0, 0xA1, 0x00, 0x58, 0x47, 0x72, 0xED, 0xAE, 0xB7, 0xA2, 0x10, + 0xE4, 0x47, 0x5D, 0xF2, 0x86, 0x0B, 0x0B, 0x10, 0x30, 0x81, 0xEB, 0x21, 0x0E, 0x99, 0x98, 0x42, + 0x6D, 0xA3, 0x09, 0xEE, 0x33, 0xDC, 0x44, 0x1E, 0x99, 0x89, 0xEC, 0x46, 0x1E, 0x9B, 0x47, 0x2E, + 0x13, 0x9A, 0x23, 0x08, 0x73, 0xEC, 0x44, 0x03, 0x30, 0x85, 0xA7, 0xE9, 0xE9, 0x5F, 0xE3, 0xCC, + 0xD2, 0xBC, 0xC9, 0xCC, 0xB2, 0x78, 0x48, 0x22, 0xBF, 0xFD, 0x27, 0x85, 0x7C, 0x21, 0x00, 0x13, + 0xCE, 0x08, 0x09, 0xF5, 0x88, 0x04, 0xE1, 0x82, 0x01, 0x61, 0x3F, 0xE2, 0xA7, 0xC7, 0x38, 0x00, + 0x63, 0x20, 0xA0, 0xAA, 0xDF, 0x04, 0xC3, 0x01, 0x62, 0xE0, 0x83, 0x56, 0xA2, 0x93, 0x8B, 0xA1, + 0xBA, 0x4E, 0x7F, 0x4F, 0xA3, 0xE7, 0xFF, 0x7F, 0xE9, 0x10, 0x5D, 0xBA, 0xCF, 0xFF, 0xFA, 0xC4, + 0xBF, 0x3A, 0x46, 0x9E, 0x8D, 0xB9, 0x52, 0x82, 0x80, 0xBD, 0x29, 0xDA, 0x9C, 0x82, 0xE4, 0x46, + 0x8E, 0xB5, 0x9F, 0x94, 0x7E, 0x73, 0xF3, 0x99, 0x63, 0x6A, 0x8A, 0xDF, 0x9F, 0xC0, 0xC7, 0xEC, + 0x0B, 0xDD, 0x7E, 0x0F, 0x47, 0x93, 0xB4, 0x4E, 0xCE, 0x9F, 0x27, 0x6E, 0xBD, 0xD4, 0xDC, 0x9D, + 0x3E, 0x7B, 0x28, 0x3C, 0x10, 0xE6, 0x04, 0x33, 0x10, 0x32, 0x34, 0xC2, 0x19, 0x1D, 0xE5, 0x34, + 0x01, 0xFE, 0x6B, 0xAD, 0x3E, 0xFD, 0x88, 0xA5, 0x18, 0xCA, 0x4D, 0xF6, 0xD4, 0x17, 0xA5, 0x64, + 0x99, 0x9F, 0xF7, 0x43, 0x8F, 0x6D, 0xD0, 0x44, 0x52, 0x1C, 0x60, 0x10, 0x72, 0x70, 0xFB, 0xFF, + 0xC4, 0x1A, 0x21, 0xA2, 0xBC, 0x4C, 0x7F, 0xFF, 0xEA, 0x1F, 0x79, 0x48, 0x04, 0x18, 0x11, 0x0B, + 0x08, 0x45, 0x8E, 0x6D, 0xFE, 0x33, 0x1E, 0xAF, 0xA7, 0x0C, 0xFC, 0xC9, 0x3A, 0x48, 0x0B, 0x8D, + 0x3D, 0x72, 0x03, 0x5D, 0x5E, 0x78, 0xE6, 0x0C, 0xEE, 0x9F, 0x07, 0x5B, 0x95, 0x8C, 0x53, 0x4A, + 0x80, 0x0A, 0x46, 0x81, 0xE1, 0xCE, 0x8B, 0x22, 0x30, 0x42, 0x20, 0x00, 0xDC, 0xF9, 0xCE, 0xAF, + 0x5D, 0x04, 0x64, 0x31, 0x4E, 0xA7, 0x70, 0x40, 0x0C, 0x7A, 0xB9, 0xEF, 0x65, 0x74, 0x68, 0x77, + 0xDF, 0xFF, 0xF0, 0xEF, 0x08, 0xDC, 0x38, 0xFC, 0x63, 0xA4, 0xD5, 0x6A, 0x15, 0xF4, 0x15, 0x0B, + 0x34, 0x75, 0x4C, 0x86, 0x48, 0x05, 0x49, 0x25, 0x60, 0x83, 0x22, 0xF5, 0x1E, 0x9C, 0x32, 0xB3, + 0x53, 0xB4, 0xB2, 0x7E, 0xCB, 0xAD, 0xF1, 0x43, 0x77, 0xC4, 0xD6, 0xBB, 0x02, 0x99, 0xDC, 0x81, + 0xA3, 0x87, 0x10, 0x03, 0x09, 0x06, 0x16, 0x2E, 0xD3, 0x04, 0x94, 0x43, 0xA2, 0x1C, 0x82, 0x64, + 0x88, 0x13, 0x01, 0xDA, 0x65, 0x02, 0xED, 0x66, 0xB3, 0xC6, 0xA2, 0xC6, 0xFF, 0xFB, 0x92, 0x64, + 0x20, 0x8C, 0x03, 0x83, 0x58, 0x3F, 0x93, 0x26, 0x2C, 0x70, 0x4C, 0xCA, 0xF8, 0x33, 0x20, 0x25, + 0xB6, 0xCE, 0x6D, 0x5C, 0xFC, 0x0C, 0x98, 0x6F, 0xC1, 0x61, 0x92, 0xA1, 0x18, 0x60, 0x8C, 0xE1, + 0xDD, 0xA7, 0x9D, 0x9C, 0xD3, 0x79, 0x85, 0x9D, 0x07, 0x37, 0x76, 0x63, 0xE6, 0xE8, 0x22, 0x54, + 0x8D, 0x11, 0x3B, 0xA0, 0x88, 0xF0, 0xFF, 0x55, 0x64, 0x12, 0x6C, 0x68, 0x1C, 0x45, 0xA6, 0x23, + 0x31, 0x7B, 0x3F, 0xFC, 0x2B, 0x09, 0x35, 0x43, 0xD8, 0x80, 0xFE, 0xBF, 0xF9, 0xC0, 0x31, 0xE0, + 0x00, 0x08, 0x02, 0x8A, 0x40, 0x38, 0xA6, 0x24, 0xD5, 0x44, 0xB5, 0x64, 0x3F, 0xC7, 0x03, 0xB4, + 0xD7, 0x82, 0xA5, 0x25, 0xB3, 0xF9, 0xB0, 0x56, 0x8D, 0x9B, 0xB1, 0x59, 0x67, 0x99, 0x8C, 0xC4, + 0x3A, 0x84, 0x7D, 0x87, 0x23, 0xEF, 0x77, 0x51, 0x2C, 0xDC, 0xFD, 0x6C, 0x96, 0x93, 0xA5, 0x55, + 0xD7, 0x69, 0xD4, 0xFD, 0x7F, 0xFF, 0xBD, 0x3F, 0x7F, 0xC9, 0xD3, 0xFC, 0xCC, 0x03, 0xB8, 0x80, + 0xF5, 0xC4, 0x67, 0x7C, 0x12, 0x2A, 0x58, 0x03, 0xF0, 0x00, 0x60, 0xCD, 0x29, 0x48, 0x57, 0x83, + 0x79, 0x74, 0xC5, 0x3C, 0xCA, 0x5D, 0x6B, 0x8F, 0x19, 0x0C, 0xB5, 0x8C, 0xC3, 0x7F, 0x45, 0xD8, + 0x87, 0xD4, 0x3C, 0xA2, 0x78, 0xC9, 0xA0, 0x92, 0x27, 0xAC, 0x7B, 0xCB, 0xB1, 0x37, 0x4E, 0x30, + 0xA7, 0x2F, 0x2B, 0x6C, 0x9A, 0x26, 0x52, 0x32, 0x53, 0x6A, 0x41, 0x5A, 0xC5, 0x0C, 0xAB, 0x40, + 0x54, 0xF2, 0xCB, 0xD2, 0x2B, 0x31, 0xAD, 0x2E, 0xF9, 0xF4, 0x38, 0x35, 0x60, 0xE4, 0xCE, 0x88, + 0x84, 0x14, 0xE0, 0x96, 0xA8, 0xEA, 0x27, 0xA6, 0x0B, 0x43, 0xA5, 0x2C, 0x4B, 0x43, 0x38, 0xD3, + 0x44, 0x57, 0xDC, 0x9C, 0x81, 0x22, 0x6C, 0x2F, 0xFA, 0xE7, 0x4C, 0x9B, 0xA2, 0xFF, 0x58, 0x70, + 0xFF, 0x91, 0xF7, 0xCE, 0x9F, 0x84, 0x27, 0xFA, 0x22, 0x07, 0x3C, 0x2E, 0xF5, 0xE9, 0x58, 0xE1, + 0x11, 0x4A, 0xAC, 0xC5, 0x12, 0x4C, 0xC8, 0x1B, 0x2C, 0x9B, 0x04, 0x6C, 0xD0, 0x59, 0xA5, 0xAB, + 0x49, 0xB9, 0x60, 0x00, 0x00, 0x6C, 0x34, 0x16, 0x4C, 0xE9, 0x46, 0xB3, 0x4A, 0x2E, 0x92, 0x32, + 0xB4, 0x21, 0xC8, 0x4D, 0x63, 0x72, 0xCC, 0xCD, 0xB0, 0x58, 0x02, 0x93, 0xB8, 0x4F, 0x44, 0x1B, + 0x88, 0x7E, 0xFF, 0x7B, 0xD3, 0x79, 0xC1, 0x2F, 0xA8, 0x5E, 0xF6, 0x07, 0x98, 0x9E, 0x01, 0x1F, + 0xCD, 0xDF, 0x50, 0x7F, 0xFF, 0x31, 0x3F, 0xEB, 0x37, 0xFE, 0x07, 0xCF, 0xC4, 0x06, 0x60, 0xAC, + 0x9D, 0xE3, 0xB7, 0xFC, 0x33, 0xFF, 0x82, 0x3A, 0x00, 0x06, 0x52, 0xBA, 0x95, 0xEC, 0xA3, 0x70, + 0x4A, 0xF0, 0x08, 0xD0, 0x98, 0xB5, 0x8C, 0x35, 0x7A, 0xAC, 0x8F, 0xF0, 0xD6, 0x3F, 0xD0, 0xC0, + 0x98, 0x90, 0xC8, 0xAD, 0xC5, 0xE1, 0x39, 0x91, 0xA7, 0x23, 0x92, 0x9A, 0xDA, 0x09, 0x86, 0x39, + 0x40, 0x9E, 0xEC, 0x6F, 0xC9, 0x58, 0x79, 0x51, 0x51, 0x69, 0x1C, 0x2F, 0x2D, 0xD4, 0xFF, 0xFB, + 0x92, 0x64, 0x1B, 0x08, 0x83, 0x06, 0x66, 0x42, 0xCB, 0x23, 0x13, 0xF0, 0x50, 0x63, 0x28, 0x59, + 0x18, 0x23, 0x3E, 0x4B, 0x20, 0xBF, 0x08, 0xAC, 0x84, 0x6A, 0xC8, 0xF5, 0x10, 0x61, 0xC8, 0x20, + 0x8C, 0xF8, 0x5D, 0xF6, 0x3A, 0xA4, 0xA5, 0x06, 0x44, 0xB3, 0x56, 0x8C, 0x67, 0xB2, 0xAB, 0x26, + 0xBA, 0x6B, 0xD9, 0x3B, 0x7E, 0x86, 0x0D, 0x35, 0x35, 0x2F, 0xDF, 0xEC, 0x54, 0xB5, 0x93, 0x73, + 0x83, 0x07, 0xFE, 0x9D, 0x4F, 0x9D, 0x66, 0x74, 0x35, 0xA7, 0x1F, 0x0C, 0x28, 0x00, 0x20, 0x05, + 0x94, 0x04, 0x8C, 0x42, 0x40, 0xBB, 0x94, 0x99, 0x28, 0x81, 0x26, 0x15, 0x6B, 0x33, 0x20, 0x95, + 0x33, 0x76, 0xC6, 0x7E, 0x18, 0xAA, 0xB5, 0x61, 0xA6, 0xC2, 0xFD, 0xA8, 0x6B, 0x38, 0xE8, 0x43, + 0x2B, 0x29, 0xB1, 0x32, 0xEE, 0xD7, 0xE7, 0x5D, 0x1B, 0x77, 0xDF, 0x2C, 0x50, 0x71, 0xF9, 0x7F, + 0x3C, 0x8F, 0xD0, 0xF7, 0xD7, 0xDF, 0x65, 0xEF, 0xE1, 0xC5, 0xF8, 0x75, 0xFC, 0x2F, 0xF6, 0x4D, + 0x2A, 0x15, 0x3D, 0xAE, 0xFB, 0xBF, 0xF9, 0xF5, 0xFC, 0x6B, 0x7F, 0x5C, 0xFD, 0x90, 0xDE, 0xA4, + 0x11, 0x92, 0x0F, 0xD9, 0xDA, 0x64, 0x76, 0x18, 0x1C, 0x8E, 0xC5, 0x15, 0xD8, 0x54, 0x0A, 0x82, + 0xCA, 0x69, 0x6B, 0x59, 0x4B, 0x8B, 0x95, 0xE1, 0x48, 0x9F, 0x35, 0x22, 0xF7, 0x86, 0x9E, 0xC9, + 0x4F, 0x5D, 0x6C, 0x49, 0x3E, 0x72, 0x65, 0x39, 0xD3, 0x7D, 0x58, 0x9B, 0xE8, 0x27, 0xCB, 0x60, + 0x2D, 0x5F, 0xA2, 0x21, 0xAC, 0xF5, 0x9F, 0x8D, 0xAD, 0x5A, 0xFC, 0x26, 0xEB, 0xDB, 0x10, 0x0B, + 0x40, 0x77, 0x35, 0xBF, 0xA7, 0x33, 0xB2, 0x8C, 0xC6, 0x8F, 0xF5, 0x3E, 0xED, 0x3A, 0x3F, 0xDF, + 0xFF, 0xF5, 0xDF, 0xE6, 0xED, 0xDD, 0xB5, 0x22, 0x2A, 0xDE, 0xD7, 0x19, 0x95, 0x1C, 0xCA, 0x5C, + 0x0F, 0xFA, 0x06, 0x69, 0x30, 0x86, 0xDF, 0x17, 0xF2, 0xC6, 0x85, 0xD6, 0xCC, 0xCB, 0x0B, 0xA1, + 0x8E, 0x91, 0x75, 0x9C, 0x11, 0x26, 0xEA, 0x74, 0x12, 0x7D, 0x17, 0x96, 0x61, 0xA7, 0x1C, 0x48, + 0x45, 0xF1, 0x9D, 0x3D, 0xCD, 0x21, 0xB3, 0xCD, 0xB8, 0x08, 0xDE, 0x70, 0x86, 0xC7, 0x9E, 0x8A, + 0xDB, 0xD3, 0x75, 0xF5, 0x00, 0x00, 0x61, 0x55, 0x15, 0xA6, 0x08, 0x32, 0x08, 0x03, 0x3D, 0x12, + 0x56, 0x6B, 0xB2, 0x06, 0x07, 0xB9, 0x73, 0x72, 0xC6, 0x9A, 0xC8, 0x59, 0x77, 0xA8, 0xCC, 0x6D, + 0xBB, 0x8C, 0xFE, 0x73, 0x68, 0xD9, 0xC3, 0x0A, 0x73, 0x4E, 0x0B, 0x6F, 0x57, 0x16, 0x26, 0x78, + 0x9E, 0xC0, 0xFD, 0x5D, 0xFD, 0x74, 0x9C, 0x89, 0xEC, 0x4B, 0xF8, 0x90, 0xBA, 0x3C, 0xDF, 0xB3, + 0x24, 0xE8, 0xDE, 0x90, 0x65, 0x1F, 0x60, 0x8F, 0xB6, 0xCD, 0x66, 0xDF, 0xF4, 0xE3, 0xF2, 0x9B, + 0xF7, 0x85, 0x8A, 0x5D, 0x64, 0xF3, 0x28, 0xF7, 0x6B, 0xFF, 0x7F, 0xAF, 0x48, 0x10, 0x80, 0x14, + 0x3D, 0x30, 0xCB, 0xA7, 0x51, 0x76, 0xEF, 0xB9, 0x70, 0xA2, 0x4B, 0xEB, 0xA2, 0x69, 0xF6, 0x77, + 0xFF, 0xFB, 0x92, 0x64, 0x36, 0x00, 0xD2, 0xC7, 0x0F, 0xC2, 0xCB, 0x09, 0x11, 0x92, 0x45, 0xE4, + 0xC8, 0x62, 0x0C, 0xC2, 0xC0, 0x09, 0x9C, 0x3B, 0x13, 0x2C, 0x30, 0x64, 0x80, 0xF4, 0x8D, 0x21, + 0xC4, 0x60, 0x8D, 0x40, 0xA8, 0x48, 0x32, 0x9F, 0x9F, 0x16, 0x23, 0x0F, 0x76, 0x54, 0xFC, 0xB7, + 0x3A, 0x0B, 0x50, 0xA8, 0x2A, 0x2C, 0x23, 0xA0, 0x70, 0xC4, 0xA5, 0x53, 0xE9, 0x60, 0xAA, 0x12, + 0xE0, 0x02, 0x2C, 0x58, 0x8A, 0x87, 0xF5, 0x22, 0xB5, 0xB1, 0x23, 0x62, 0xAF, 0x91, 0xAF, 0x4F, + 0xBD, 0x22, 0xBA, 0xB2, 0x14, 0x5F, 0xA0, 0x04, 0x82, 0x6B, 0xBA, 0xAA, 0xF7, 0xE4, 0xAF, 0x12, + 0x14, 0x44, 0xB2, 0x11, 0x65, 0x91, 0x8D, 0x6A, 0xA7, 0x1F, 0x2E, 0xF3, 0xD7, 0xB0, 0x2C, 0xEA, + 0x5E, 0x1A, 0x3C, 0x7C, 0xDB, 0x18, 0x51, 0x81, 0xF0, 0xA8, 0xF0, 0x71, 0xA9, 0x10, 0x0A, 0x30, + 0xA2, 0xC5, 0x6E, 0x40, 0x11, 0x4D, 0xBC, 0x8B, 0xF7, 0x34, 0x30, 0x95, 0x94, 0xEC, 0x59, 0xDB, + 0x14, 0x6C, 0x7E, 0x4D, 0xA0, 0x4A, 0x66, 0x25, 0x96, 0xCB, 0x1F, 0x0C, 0x29, 0x0B, 0xDF, 0x7B, + 0xEF, 0x42, 0xEA, 0x42, 0xCF, 0x07, 0x45, 0xEB, 0x5B, 0xE5, 0xAF, 0x17, 0x52, 0x34, 0xFE, 0x3D, + 0x9E, 0x5D, 0x93, 0xDC, 0xA6, 0x5D, 0xF5, 0x2C, 0x90, 0x58, 0x77, 0x83, 0x65, 0x4E, 0x85, 0x43, + 0x05, 0xD1, 0x0A, 0x8C, 0x04, 0xC1, 0xA1, 0x51, 0x48, 0x9E, 0x88, 0xBB, 0xCD, 0x20, 0xCA, 0x5A, + 0x16, 0x5C, 0xCA, 0x19, 0x4F, 0xB5, 0x9D, 0x06, 0xAB, 0xF9, 0x47, 0x74, 0xBF, 0x6F, 0xF3, 0x9F, + 0xA9, 0x86, 0x47, 0x74, 0x74, 0xAA, 0x1E, 0x08, 0x3B, 0x30, 0x18, 0x0F, 0x09, 0xFB, 0x31, 0x82, + 0xAB, 0x5E, 0x69, 0xF1, 0x36, 0xDF, 0x14, 0xC2, 0x7F, 0xFC, 0x22, 0x24, 0xB9, 0x1F, 0x48, 0xA2, + 0xB6, 0x6A, 0xCA, 0xAD, 0x3E, 0x0E, 0x9C, 0x06, 0x2E, 0xB7, 0x06, 0x69, 0x94, 0x33, 0xBF, 0x92, + 0xB0, 0xEC, 0x3B, 0x2E, 0x71, 0x4C, 0x78, 0xE3, 0xF9, 0xA7, 0xF3, 0x3D, 0xA2, 0x7F, 0xF6, 0x41, + 0x2B, 0xFE, 0xCB, 0xA4, 0xFF, 0xC3, 0x5D, 0xA3, 0xC5, 0x2D, 0x9D, 0xEF, 0x7D, 0x9F, 0xCF, 0x7B, + 0xC7, 0xEF, 0x67, 0x59, 0xFF, 0xA9, 0x58, 0xA8, 0xD3, 0xBB, 0xEA, 0x4F, 0xD6, 0xC0, 0x0D, 0x54, + 0xA0, 0xA0, 0x08, 0x48, 0x0F, 0x8A, 0x1C, 0xE2, 0x92, 0x91, 0x49, 0x6A, 0x38, 0xC1, 0x73, 0x6B, + 0xDC, 0xD5, 0x38, 0xF7, 0x04, 0xF2, 0x7F, 0x49, 0xDA, 0xC2, 0xB3, 0x52, 0xAE, 0xCD, 0x11, 0x42, + 0x0E, 0x8B, 0x58, 0x19, 0xF5, 0xA2, 0xF1, 0xD6, 0xBE, 0xB1, 0xD3, 0x66, 0x0B, 0xBA, 0xF4, 0x3A, + 0x9F, 0xFF, 0xEA, 0xA3, 0xFA, 0x3A, 0xBD, 0x0D, 0x48, 0x08, 0xFC, 0xB2, 0x20, 0xD8, 0xDB, 0xE3, + 0x3C, 0x8B, 0x0C, 0x1E, 0xC9, 0x0D, 0xAA, 0x2E, 0x91, 0x27, 0x3C, 0x47, 0x65, 0x3E, 0xCF, 0x4D, + 0x08, 0xD8, 0xD0, 0xDC, 0x58, 0x2A, 0x79, 0xCA, 0x30, 0x30, 0xE3, 0xF5, 0x03, 0x93, 0x43, 0x06, + 0xC8, 0x6D, 0xFF, 0xFB, 0x92, 0x64, 0x60, 0x8C, 0x82, 0xE2, 0x1E, 0x41, 0x83, 0x0F, 0x19, 0x42, + 0x3A, 0x24, 0xA8, 0x96, 0x0C, 0x23, 0x58, 0x0B, 0x68, 0x9D, 0x0A, 0x4C, 0xA4, 0x66, 0x81, 0x1D, + 0x21, 0x61, 0xC4, 0x80, 0x8B, 0xC8, 0x5E, 0x65, 0xD4, 0xA8, 0x3C, 0xF0, 0x45, 0x85, 0x8C, 0xB4, + 0x14, 0x9F, 0x7A, 0x06, 0x29, 0x8C, 0x1E, 0xD3, 0xF1, 0x5C, 0x98, 0xBD, 0x84, 0xE9, 0x16, 0x44, + 0x1A, 0x15, 0x2A, 0x55, 0x64, 0x55, 0xBC, 0x15, 0x30, 0x58, 0xDB, 0xC5, 0x4F, 0xBE, 0x8B, 0x5C, + 0x91, 0xBB, 0x0F, 0x59, 0x45, 0x48, 0x76, 0x40, 0x81, 0x34, 0x0C, 0x10, 0x5E, 0x6A, 0xE5, 0x27, + 0x94, 0xE2, 0xD2, 0x1B, 0xAB, 0xE2, 0xA2, 0xD2, 0x28, 0xFB, 0xE1, 0x1A, 0xA9, 0xCB, 0x3E, 0xAB, + 0xEA, 0x24, 0xDE, 0x25, 0xEB, 0xEF, 0xAB, 0xAF, 0x46, 0x65, 0x6A, 0x2F, 0x65, 0x3F, 0x4E, 0x62, + 0x44, 0x21, 0xB7, 0x6E, 0xA6, 0xF8, 0xC5, 0x47, 0x99, 0x32, 0xDD, 0x17, 0x9E, 0xED, 0x46, 0x46, + 0xC5, 0xBB, 0xA4, 0x3F, 0xA7, 0x31, 0xD2, 0xA7, 0xED, 0xC5, 0x74, 0x58, 0xFC, 0x06, 0x81, 0x05, + 0x5A, 0x73, 0x53, 0x13, 0x31, 0x57, 0x04, 0x54, 0xA2, 0x03, 0x94, 0x48, 0xF8, 0xC2, 0x15, 0x00, + 0x89, 0x6D, 0x54, 0xAF, 0x7C, 0xBE, 0xE0, 0xDE, 0xCD, 0x74, 0x56, 0xE6, 0x7F, 0x72, 0xC9, 0xFB, + 0x73, 0xCC, 0xCF, 0xCB, 0x76, 0xFA, 0xCD, 0x5F, 0x4D, 0xF3, 0x3F, 0xA7, 0x33, 0x39, 0x6C, 0x4E, + 0xBE, 0x63, 0x86, 0x71, 0x86, 0x2A, 0x90, 0x0B, 0x5E, 0x75, 0x58, 0xCC, 0x5A, 0x49, 0x8B, 0x07, + 0x5E, 0x06, 0x1B, 0x1E, 0x20, 0x78, 0xF5, 0xB9, 0x2F, 0x58, 0xEE, 0x48, 0x7B, 0x6F, 0x2E, 0xF9, + 0xE1, 0x0D, 0x29, 0x49, 0x94, 0x99, 0xD8, 0x40, 0x08, 0x3A, 0xE2, 0xC1, 0xBD, 0x84, 0x70, 0xAA, + 0xCC, 0xAB, 0xE9, 0x03, 0x58, 0x07, 0x22, 0xE3, 0x8C, 0x4E, 0xCE, 0x74, 0x95, 0xBA, 0xE5, 0xF4, + 0x8C, 0x1A, 0xB8, 0x2E, 0x11, 0x18, 0x64, 0xF8, 0x64, 0x2C, 0xE7, 0x8F, 0x42, 0x92, 0xC8, 0x2E, + 0x44, 0xF0, 0x64, 0x48, 0x80, 0x2A, 0x52, 0xE0, 0x58, 0xA2, 0x40, 0xD6, 0xBC, 0x73, 0x6E, 0xB4, + 0xF1, 0x40, 0xF0, 0xCF, 0x16, 0xBB, 0xFD, 0x11, 0xEA, 0xFF, 0xAE, 0x48, 0x65, 0x01, 0x6C, 0x15, + 0x0A, 0x07, 0x82, 0xC0, 0x9B, 0x5D, 0x42, 0xA7, 0x36, 0xD4, 0x7E, 0x4D, 0x8E, 0x50, 0x6F, 0x64, + 0x3E, 0x8F, 0x9F, 0xCF, 0xA4, 0xA7, 0x67, 0xFD, 0x29, 0xEA, 0xCD, 0xA3, 0xA8, 0xE6, 0xA9, 0x4C, + 0x93, 0xC6, 0x24, 0xB2, 0x45, 0x2A, 0x50, 0x6D, 0xE7, 0x07, 0xEF, 0x53, 0xD4, 0xB1, 0x0A, 0x9E, + 0x07, 0xD6, 0xB5, 0x98, 0x2C, 0x54, 0xA1, 0x04, 0xCC, 0xAA, 0xF3, 0x2B, 0x62, 0x86, 0xA5, 0xD1, + 0x8C, 0x42, 0x54, 0xD3, 0x8D, 0x50, 0xE6, 0xAC, 0x4C, 0xBB, 0xC9, 0xAE, 0x44, 0xF3, 0x52, 0x79, + 0x27, 0x05, 0x5A, 0x5A, 0xD5, 0x06, 0x90, 0x14, 0x30, 0xA0, 0x83, 0xB1, 0x61, 0xAC, 0x89, 0x53, + 0x0F, 0x3F, 0xB5, 0x42, 0xFF, 0xFB, 0x92, 0x64, 0x83, 0x0C, 0x82, 0xC7, 0x30, 0xC2, 0x03, 0x09, + 0x19, 0xE0, 0x44, 0xE3, 0xA8, 0x82, 0x0C, 0x23, 0x84, 0x0B, 0x2C, 0x77, 0x0C, 0x4C, 0x30, 0x68, + 0x81, 0x0F, 0x0B, 0xA2, 0x58, 0x61, 0x0C, 0xA9, 0x89, 0x18, 0x23, 0x01, 0x9D, 0x34, 0x12, 0xE8, + 0xE0, 0x0E, 0xB4, 0x2E, 0x9C, 0x01, 0x3C, 0xD4, 0xA8, 0xC4, 0x73, 0x35, 0xFA, 0xD6, 0x6A, 0xB3, + 0x7E, 0x77, 0x5A, 0xB7, 0xDD, 0xD3, 0x76, 0xE9, 0x3C, 0x33, 0xB3, 0x3D, 0xC8, 0xB7, 0x76, 0xE8, + 0x82, 0xF9, 0xFF, 0x33, 0xA6, 0xBE, 0xFD, 0xBF, 0x76, 0xB0, 0x77, 0xEF, 0xF9, 0x02, 0x41, 0x05, + 0xDA, 0x91, 0xAB, 0xA9, 0x40, 0xD6, 0xAB, 0xB0, 0x1E, 0x2D, 0x2A, 0xA4, 0x93, 0x46, 0x24, 0xD0, + 0x1B, 0x1A, 0x01, 0x94, 0x64, 0x6F, 0xB9, 0xF4, 0x8C, 0xA7, 0xFB, 0xE7, 0x20, 0x96, 0x92, 0x13, + 0x76, 0xA1, 0xE5, 0x41, 0x12, 0xAC, 0x6C, 0x8C, 0xF3, 0x47, 0x9F, 0x47, 0x1C, 0xA7, 0x8D, 0x71, + 0xF6, 0x92, 0x53, 0x89, 0x77, 0x9D, 0xD9, 0xA0, 0xF7, 0x54, 0x77, 0x46, 0x67, 0x92, 0xC5, 0x51, + 0x5E, 0x30, 0xC8, 0xB0, 0xC2, 0xFD, 0x83, 0xDA, 0xAA, 0x9F, 0x3A, 0xFA, 0x00, 0x11, 0xE5, 0x10, + 0x01, 0xA5, 0x67, 0xBD, 0xA5, 0x19, 0xFB, 0xB6, 0xEA, 0xEB, 0xEB, 0x76, 0x8C, 0xCF, 0xFA, 0x00, + 0x47, 0xA0, 0x96, 0xC1, 0x3B, 0xCF, 0xD1, 0x4C, 0x0B, 0x9B, 0x14, 0xD4, 0xC4, 0x4B, 0xCC, 0x43, + 0x28, 0xDA, 0x22, 0x22, 0x8A, 0x8C, 0x34, 0x20, 0x0B, 0x2A, 0x38, 0x89, 0x20, 0xF9, 0x73, 0x25, + 0x1B, 0x3C, 0x0E, 0xA1, 0x46, 0x8F, 0x98, 0x9E, 0x79, 0x7A, 0xCF, 0x31, 0xBE, 0xBB, 0x8B, 0x0D, + 0xDB, 0x4E, 0x97, 0x7C, 0x53, 0x8F, 0x78, 0x0A, 0x81, 0x32, 0x80, 0x8A, 0xD6, 0x46, 0x50, 0x31, + 0x4F, 0x11, 0x84, 0x7C, 0x8A, 0xFF, 0x05, 0x7A, 0x30, 0x7D, 0x36, 0xA4, 0x8B, 0x4C, 0x4D, 0x65, + 0x3E, 0xE5, 0x0B, 0x58, 0xF9, 0x3D, 0x44, 0x91, 0x6C, 0x49, 0x5B, 0x33, 0x3A, 0xB9, 0xEC, 0x74, + 0x90, 0x1B, 0x10, 0xB6, 0x10, 0x27, 0x5A, 0x5B, 0xC5, 0xA7, 0xCB, 0xAC, 0xCB, 0x00, 0x46, 0x05, + 0x44, 0xC1, 0x82, 0x0D, 0x38, 0x1D, 0x46, 0x79, 0x55, 0xAD, 0x48, 0x11, 0x9B, 0x14, 0x91, 0x99, + 0x3C, 0xA8, 0xAA, 0x85, 0x8E, 0x03, 0x14, 0x09, 0x58, 0x38, 0x50, 0x69, 0xFA, 0x1E, 0x3C, 0xDA, + 0x19, 0x75, 0x94, 0x31, 0x7A, 0x40, 0x6E, 0x81, 0x33, 0x09, 0xA8, 0x66, 0xC2, 0x38, 0x76, 0x30, + 0x1D, 0xBC, 0xD4, 0xA6, 0x22, 0x81, 0x8A, 0x69, 0xA4, 0x6A, 0x0C, 0x77, 0xA2, 0x43, 0x40, 0xC8, + 0x59, 0x06, 0x8F, 0x11, 0x36, 0x50, 0x92, 0x81, 0x86, 0x1F, 0x00, 0xC0, 0xA0, 0x11, 0xC1, 0xF1, + 0x77, 0x25, 0x43, 0x8B, 0x3D, 0x6C, 0xCC, 0xBA, 0xFA, 0x14, 0xEC, 0x75, 0xB5, 0x6E, 0x76, 0xBE, + 0xEB, 0x77, 0xEE, 0xD9, 0x5F, 0xFD, 0x6A, 0x00, 0x6C, 0x82, 0x03, 0x15, 0x2E, 0xB8, 0xFA, 0xB0, + 0x09, 0x93, 0x32, 0x19, 0xA7, 0x85, 0xFF, 0xFB, 0x92, 0x64, 0xA4, 0x80, 0x82, 0x74, 0x25, 0x44, + 0xCB, 0x26, 0x1A, 0x20, 0x4B, 0x24, 0x48, 0x92, 0x18, 0x22, 0xC2, 0x0B, 0xD4, 0x6F, 0x0F, 0x2C, + 0xBC, 0x65, 0x01, 0x04, 0x8A, 0xE2, 0xA0, 0x60, 0x8C, 0xE0, 0x81, 0xC8, 0x13, 0x71, 0xF3, 0xB8, + 0xB8, 0x08, 0x36, 0xC0, 0xA8, 0x08, 0x99, 0x9D, 0xAE, 0x2F, 0x8C, 0x48, 0x84, 0x2A, 0xB2, 0x8F, + 0xF4, 0x2E, 0x91, 0x0C, 0x16, 0x3A, 0xEA, 0x0A, 0xE9, 0xBB, 0xBC, 0x8D, 0x5F, 0xE4, 0x56, 0xB1, + 0x95, 0xCD, 0x2C, 0xC2, 0x1A, 0x58, 0x30, 0x72, 0x80, 0xB1, 0x16, 0x56, 0x84, 0xEE, 0x12, 0x5C, + 0xF6, 0x09, 0x7A, 0x8A, 0xAF, 0x5D, 0x97, 0xB4, 0x75, 0x1B, 0xCF, 0xEA, 0x50, 0x20, 0x25, 0x72, + 0x1B, 0x26, 0xF5, 0x52, 0x4C, 0x3C, 0x94, 0xD2, 0x02, 0x08, 0xBF, 0xB3, 0xD0, 0x3B, 0x6A, 0x13, + 0xC3, 0x6B, 0x77, 0x6F, 0x2D, 0xFE, 0x67, 0xBD, 0x7D, 0xC8, 0x70, 0x7C, 0x63, 0x19, 0x8E, 0xCF, + 0x53, 0xDE, 0x2D, 0x39, 0x4B, 0x76, 0x92, 0x1A, 0x03, 0x03, 0xB2, 0x36, 0xA4, 0x93, 0xBA, 0x4C, + 0xB8, 0x0C, 0x94, 0x66, 0x66, 0x15, 0x59, 0x28, 0x83, 0xFE, 0x17, 0x5F, 0xDF, 0xDB, 0xD3, 0x39, + 0xDA, 0xB5, 0x13, 0x68, 0x90, 0x9E, 0x1F, 0xAA, 0x45, 0x81, 0x05, 0xD0, 0x19, 0x62, 0x61, 0xC9, + 0x29, 0x89, 0xD2, 0x20, 0xAE, 0x44, 0x60, 0x99, 0xA3, 0x53, 0x55, 0xD6, 0x13, 0xC3, 0x02, 0x30, + 0x4F, 0xB5, 0x76, 0xE1, 0x17, 0xE2, 0xD4, 0xBA, 0xA6, 0x9A, 0x82, 0x04, 0x88, 0x1C, 0xF1, 0xDE, + 0x3C, 0x48, 0xAF, 0xE6, 0x8D, 0x19, 0x11, 0x68, 0xA2, 0xC8, 0xF3, 0xFA, 0xD3, 0xCC, 0x9E, 0x5D, + 0xFD, 0xBE, 0x30, 0x73, 0x69, 0x3F, 0x3F, 0xC1, 0xC9, 0xC0, 0x20, 0xF3, 0xC4, 0xF6, 0xD4, 0xC3, + 0xE8, 0x68, 0xE4, 0x97, 0x75, 0x83, 0xC9, 0x29, 0xB7, 0x99, 0x63, 0xB3, 0x03, 0x08, 0x0A, 0x20, + 0x00, 0x89, 0xE7, 0x19, 0xB8, 0x19, 0xB2, 0x3E, 0x45, 0x40, 0x08, 0xD5, 0xFE, 0xD5, 0x62, 0x5D, + 0xD3, 0x1F, 0xE9, 0x34, 0x79, 0x78, 0xF5, 0xE4, 0xEE, 0xAF, 0x19, 0x95, 0x55, 0xB9, 0x11, 0x49, + 0xCC, 0x19, 0x6C, 0x56, 0xDC, 0xEB, 0x3C, 0x32, 0xF3, 0x67, 0xDA, 0xBF, 0x91, 0xAB, 0x77, 0x13, + 0xE8, 0xB7, 0x6B, 0x31, 0x8E, 0x3B, 0xD4, 0x7D, 0xD8, 0xE1, 0xAD, 0xAA, 0x7B, 0xBB, 0x60, 0x98, + 0xD6, 0xDD, 0xBC, 0xD9, 0x74, 0xDF, 0xFF, 0x6F, 0xAB, 0x1D, 0x51, 0xBD, 0x43, 0xE1, 0xF4, 0x9D, + 0xD2, 0x10, 0xD7, 0x7F, 0xDD, 0x9A, 0xD0, 0x30, 0x2C, 0xE1, 0x00, 0x05, 0x00, 0x8C, 0x4D, 0x85, + 0x20, 0x8B, 0x03, 0x50, 0x82, 0x03, 0xC5, 0xB6, 0x93, 0x39, 0xC1, 0xD7, 0x72, 0xAD, 0x2C, 0xC3, + 0x34, 0x42, 0xD8, 0xF7, 0x8D, 0x64, 0xA4, 0x86, 0x32, 0x9B, 0xB2, 0x85, 0x8B, 0x34, 0x2D, 0xE6, + 0xD8, 0x3A, 0xB8, 0x77, 0xA7, 0x9F, 0x92, 0x52, 0xD2, 0xCC, 0x98, 0xFD, 0x9E, 0x9A, 0x69, 0xE5, + 0x0E, 0x02, 0xA4, 0x72, 0xE9, 0x6F, 0xFF, 0x38, 0xFF, 0xFB, 0x92, 0x64, 0xC6, 0x88, 0x02, 0xE7, + 0x2A, 0xC3, 0x33, 0x48, 0x12, 0xE0, 0x40, 0x65, 0x68, 0xC9, 0x18, 0x23, 0xC4, 0x4C, 0x24, 0xD7, + 0x0C, 0x4D, 0x18, 0x6A, 0x41, 0x30, 0x93, 0x63, 0x64, 0x60, 0x8F, 0x41, 0x85, 0x0E, 0x3F, 0x3E, + 0x7E, 0xCA, 0x61, 0xE5, 0xFC, 0x84, 0xC8, 0xCB, 0x9A, 0x63, 0x05, 0xBB, 0xB8, 0x8A, 0xFB, 0xA6, + 0xFF, 0xD6, 0xB5, 0xFB, 0x0E, 0xF6, 0x73, 0x77, 0x3B, 0xC5, 0xBD, 0x97, 0x31, 0xA5, 0xDE, 0xC8, + 0x01, 0xC2, 0xE5, 0xDB, 0x3B, 0x63, 0x45, 0x08, 0xC9, 0x41, 0x01, 0x65, 0x13, 0x51, 0x27, 0xB5, + 0x56, 0xA4, 0xCE, 0xCA, 0xD1, 0x2F, 0xC9, 0xF6, 0x97, 0x0F, 0x7B, 0x91, 0x8A, 0x40, 0xEC, 0xA2, + 0x47, 0x3A, 0xB7, 0x20, 0x4F, 0x6E, 0xBD, 0x48, 0x14, 0x83, 0x94, 0x15, 0x00, 0x5A, 0xEA, 0x8F, + 0x0A, 0x2D, 0x51, 0xF9, 0xC4, 0xB5, 0x91, 0x7D, 0x52, 0x1F, 0x42, 0x2F, 0x72, 0xFB, 0xD6, 0x21, + 0x52, 0x00, 0x8C, 0x0A, 0x58, 0x38, 0x77, 0x80, 0xAB, 0x93, 0xAF, 0x31, 0x36, 0x5C, 0x99, 0x2A, + 0x77, 0xBC, 0xB2, 0xA5, 0x3D, 0x10, 0xC7, 0x10, 0x4D, 0x24, 0xBA, 0xFD, 0x8A, 0x92, 0xE5, 0x01, + 0x24, 0x9D, 0xB4, 0x89, 0x37, 0x5A, 0x10, 0x69, 0x8E, 0x6C, 0xFA, 0xAA, 0x09, 0x03, 0x1B, 0xE7, + 0xD7, 0xDB, 0x23, 0xC7, 0xFC, 0x8D, 0xDC, 0x8B, 0xE0, 0xCA, 0x09, 0x0B, 0xD7, 0xFE, 0x4E, 0x5C, + 0xC9, 0xD4, 0x88, 0x92, 0xB4, 0xFD, 0x4F, 0xE7, 0xDB, 0xB4, 0x04, 0xB7, 0xCE, 0x04, 0x27, 0x85, + 0xE9, 0x92, 0x16, 0x07, 0xF3, 0x5C, 0xF4, 0x3F, 0xFD, 0xFF, 0x04, 0x6B, 0xF7, 0xE4, 0x8B, 0xF0, + 0x68, 0x75, 0x66, 0xD7, 0xC7, 0x45, 0x75, 0xAA, 0xE0, 0x05, 0xFA, 0x05, 0xDA, 0x07, 0xB9, 0x0C, + 0x2F, 0x60, 0x07, 0x1E, 0xA4, 0x23, 0x08, 0x1A, 0xC5, 0x3D, 0x07, 0xBA, 0x30, 0x8F, 0x6D, 0x47, + 0xC5, 0x53, 0x62, 0x0F, 0xFE, 0xF9, 0x79, 0xE1, 0x1F, 0x9F, 0xD5, 0x7F, 0x6F, 0xBB, 0xC3, 0xF8, + 0x29, 0x0B, 0x37, 0x2B, 0xE5, 0x8E, 0x43, 0x26, 0xA7, 0x13, 0x4C, 0x17, 0x48, 0x9D, 0x20, 0x26, + 0x0C, 0x07, 0x4A, 0xB0, 0x60, 0x91, 0x02, 0x60, 0x09, 0xF8, 0x2C, 0xA7, 0x98, 0x61, 0x06, 0x08, + 0x6E, 0xAC, 0x22, 0xD0, 0xEE, 0x2A, 0xF7, 0xED, 0xF3, 0x5B, 0x2F, 0x74, 0xC6, 0xFD, 0xFD, 0xD5, + 0x02, 0x39, 0x0B, 0x39, 0x1C, 0x60, 0x6A, 0xCA, 0xB0, 0x23, 0xE0, 0x5E, 0x1D, 0x3B, 0x2B, 0x14, + 0x05, 0xAB, 0x86, 0xCA, 0x93, 0x2A, 0x65, 0xBB, 0x7A, 0xC5, 0xF7, 0xE1, 0x44, 0x44, 0x11, 0x85, + 0x35, 0x42, 0x04, 0x60, 0xDF, 0x23, 0x33, 0xAF, 0x95, 0x8F, 0xED, 0x3C, 0xA7, 0x1C, 0xDF, 0xCB, + 0x7C, 0x4B, 0x0B, 0x43, 0xC1, 0xE7, 0x8B, 0x96, 0x1E, 0x4C, 0x40, 0x16, 0x22, 0xF3, 0x27, 0x1C, + 0xD2, 0x57, 0xD3, 0x83, 0x69, 0x6C, 0xFD, 0xC2, 0x33, 0x4A, 0x2A, 0x58, 0xB4, 0x22, 0x51, 0xD7, + 0x0A, 0xC3, 0x29, 0xD2, 0xA7, 0xDA, 0xE6, 0x89, 0x06, 0xB1, 0xFF, 0xFB, 0x92, 0x64, 0xE0, 0x08, + 0x03, 0x2D, 0x42, 0x42, 0x83, 0x78, 0x19, 0x42, 0x3F, 0x45, 0x09, 0x4D, 0x00, 0x23, 0x0D, 0x0D, + 0x81, 0x03, 0x0D, 0x2D, 0x18, 0x6D, 0x49, 0x52, 0x13, 0xE2, 0x54, 0xC1, 0x98, 0x58, 0x48, 0x2C, + 0xB5, 0x12, 0x42, 0xA7, 0xB6, 0x00, 0x2A, 0x0D, 0x42, 0x80, 0x8C, 0x44, 0x5E, 0x32, 0x01, 0x4A, + 0x26, 0xC7, 0xAE, 0x68, 0xD4, 0xA6, 0xAA, 0x99, 0xCA, 0x9E, 0xCD, 0x52, 0x13, 0x55, 0x92, 0xE6, + 0xA8, 0x49, 0xE4, 0xCB, 0x55, 0x15, 0x74, 0x4F, 0x69, 0x2F, 0xED, 0x4A, 0x0B, 0x37, 0x13, 0x86, + 0x0A, 0x3B, 0x02, 0x54, 0x86, 0xA6, 0x59, 0x92, 0xF4, 0x41, 0x6B, 0x84, 0x0E, 0x15, 0x11, 0x30, + 0x00, 0x0B, 0x90, 0x32, 0x22, 0x7A, 0x98, 0x5E, 0x91, 0x61, 0x7A, 0x42, 0xEF, 0x01, 0x9E, 0x5C, + 0x9D, 0x8A, 0x15, 0xC9, 0xEF, 0x68, 0xC2, 0xAD, 0x16, 0x7A, 0x0F, 0xD6, 0xDF, 0xDD, 0xFA, 0x10, + 0x03, 0x42, 0x64, 0x42, 0x40, 0x5F, 0x50, 0xD3, 0x23, 0xF6, 0x95, 0x1A, 0xA1, 0xB6, 0xF8, 0x18, + 0x32, 0x95, 0x73, 0xB0, 0xF6, 0x46, 0xA6, 0xEE, 0x18, 0x08, 0x1A, 0xD7, 0xE8, 0x08, 0x2E, 0x61, + 0x11, 0x56, 0x38, 0xBA, 0x91, 0x45, 0x18, 0x74, 0x40, 0x08, 0x43, 0x8F, 0x67, 0x62, 0x21, 0x1C, + 0xEA, 0xC2, 0x42, 0x81, 0xF3, 0x44, 0xC0, 0x81, 0xFC, 0xE2, 0xF4, 0x31, 0x00, 0x08, 0xA2, 0x3B, + 0x11, 0xDE, 0x87, 0xAA, 0x94, 0x8F, 0x2C, 0x85, 0x47, 0x1C, 0xAE, 0x1C, 0x14, 0x63, 0x10, 0xA7, + 0x32, 0x24, 0x84, 0x55, 0x2B, 0xE8, 0x8F, 0xE7, 0x62, 0x36, 0x8D, 0x74, 0x6B, 0x6E, 0xEA, 0x8E, + 0xAC, 0x55, 0x76, 0xD6, 0x46, 0x7A, 0xD2, 0x8A, 0xB6, 0xAD, 0x95, 0x7A, 0xA9, 0x84, 0x9D, 0x7F, + 0x5B, 0x9B, 0xAF, 0x14, 0x6C, 0x42, 0x76, 0xFD, 0x52, 0x00, 0x11, 0x5A, 0x22, 0xAC, 0x58, 0xC3, + 0x58, 0x24, 0x69, 0xFC, 0x95, 0x43, 0x9E, 0x4E, 0x9B, 0xBB, 0x14, 0x88, 0x28, 0x2A, 0x84, 0x14, + 0x30, 0x68, 0x22, 0x0A, 0x18, 0xC6, 0x47, 0x2E, 0x71, 0x73, 0x22, 0x14, 0x85, 0x10, 0x6A, 0x98, + 0x72, 0x23, 0x36, 0xA7, 0xE8, 0xAC, 0x6B, 0x3A, 0x51, 0x48, 0x75, 0x66, 0xDD, 0x2E, 0xAF, 0x55, + 0x57, 0x42, 0xB8, 0xBB, 0xB1, 0x9D, 0xD9, 0xBB, 0x9D, 0x7D, 0x9A, 0x46, 0x61, 0xBD, 0x7F, 0x5E, + 0xF5, 0xF9, 0xC3, 0x96, 0xEC, 0xDC, 0xAA, 0x81, 0xC4, 0xFD, 0xDB, 0xD1, 0xAF, 0xA3, 0xAA, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x01, 0x40, 0xCF, 0x0F, 0x0C, 0x60, 0x70, 0xA8, 0xD4, 0x60, 0xCE, 0x67, + 0xAB, 0xBA, 0x30, 0x9C, 0x06, 0x0F, 0x6E, 0x26, 0x22, 0x42, 0x1C, 0x30, 0x70, 0xCE, 0x47, 0x59, + 0x24, 0xFB, 0xA3, 0x1A, 0x09, 0x01, 0xC0, 0xA6, 0x64, 0x22, 0x65, 0xA4, 0x30, 0xA8, 0x0E, 0x2B, + 0x58, 0xEB, 0x4C, 0x02, 0x8D, 0xAB, 0xF0, 0xC3, 0x14, 0x54, 0x8B, 0x89, 0x45, 0x93, 0x2C, 0x08, + 0x64, 0x0B, 0x1A, 0x9D, 0x93, 0x22, 0x22, 0x26, 0x34, 0x28, 0x10, 0x48, 0xFF, 0xFB, 0x92, 0x64, + 0xEC, 0x09, 0x03, 0x09, 0x25, 0x43, 0xAB, 0x4C, 0x19, 0x50, 0x5A, 0x25, 0x48, 0xA9, 0x30, 0xC3, + 0x4E, 0x0F, 0x35, 0x89, 0x0C, 0xB5, 0xA2, 0x80, 0x09, 0x56, 0x1E, 0xE3, 0x26, 0x8C, 0x50, 0x01, + 0x57, 0xA9, 0x04, 0x21, 0x81, 0xD4, 0x70, 0x25, 0x12, 0xD7, 0xFD, 0xD7, 0x4E, 0x77, 0xDC, 0xBE, + 0xA9, 0xC6, 0xA9, 0xC4, 0x8B, 0x41, 0x32, 0x61, 0xC5, 0xAB, 0x34, 0xF9, 0xCC, 0x73, 0xDB, 0x4C, + 0x5F, 0x4F, 0xAD, 0xBC, 0xAB, 0x8D, 0x16, 0x32, 0x12, 0xEE, 0x77, 0x29, 0x98, 0x05, 0x36, 0x5A, + 0x9F, 0x91, 0xC3, 0x73, 0x5D, 0x9A, 0xB1, 0x03, 0x3E, 0xAC, 0x81, 0x87, 0xC2, 0x28, 0x15, 0x58, + 0x98, 0x81, 0xA1, 0x88, 0x8D, 0x57, 0xD4, 0xF9, 0xCB, 0xF0, 0xD6, 0xBF, 0x2F, 0x78, 0xE4, 0x54, + 0x9F, 0xAE, 0x6F, 0x9C, 0x6F, 0x9B, 0xEB, 0xDF, 0xBF, 0xD7, 0x79, 0xF8, 0x61, 0xFC, 0xDF, 0x7F, + 0x99, 0x6E, 0xF7, 0xE1, 0xAF, 0xDE, 0x1F, 0x6F, 0x3A, 0xFF, 0x8E, 0x1C, 0xFF, 0xCB, 0xF5, 0x97, + 0xDD, 0x62, 0x61, 0xC0, 0x90, 0x40, 0x2E, 0x90, 0x18, 0x3E, 0x22, 0x22, 0x71, 0x4C, 0x0B, 0xD8, + 0x90, 0xB3, 0xCE, 0xA3, 0xFF, 0xE4, 0xC0, 0x21, 0x40, 0x20, 0x62, 0x00, 0x00, 0x00, 0x00, 0x12, + 0xA3, 0x4C, 0x7F, 0x0F, 0x61, 0x5D, 0xEB, 0x71, 0x01, 0x16, 0x5C, 0x99, 0xD5, 0x0A, 0xF5, 0x7B, + 0x35, 0x17, 0x28, 0xCA, 0xA9, 0x61, 0x7F, 0x48, 0x1A, 0x43, 0x64, 0x84, 0x72, 0xFB, 0xE7, 0xA4, + 0x7D, 0x43, 0xAD, 0x61, 0x25, 0x9A, 0x23, 0x82, 0xA9, 0xED, 0x15, 0x56, 0x10, 0xD9, 0xBA, 0x0B, + 0xEB, 0x2F, 0x59, 0xED, 0xD5, 0x79, 0x07, 0x5F, 0xE9, 0x37, 0x9C, 0x86, 0xAD, 0xFB, 0x23, 0x8A, + 0xAB, 0x7F, 0x21, 0x2C, 0x98, 0xAF, 0xF1, 0x30, 0xFC, 0x5D, 0x98, 0xDE, 0x39, 0x19, 0xDD, 0xA3, + 0x5C, 0xC2, 0xBF, 0xD6, 0x1E, 0xA4, 0x6B, 0x50, 0xA9, 0x2C, 0x5E, 0x7B, 0xFF, 0x37, 0x6F, 0x14, + 0x78, 0xFE, 0xC5, 0x3B, 0xFF, 0x34, 0xCF, 0xCB, 0x74, 0xCD, 0x6D, 0x37, 0xD8, 0xFE, 0x9B, 0x6C, + 0x9B, 0xFD, 0x6B, 0x39, 0x99, 0xFD, 0x6D, 0xBD, 0xF2, 0x7F, 0x35, 0x94, 0x31, 0x43, 0x13, 0x36, + 0x64, 0x62, 0xD6, 0xDB, 0x0D, 0xFF, 0xFE, 0xFF, 0xFF, 0xD8, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x80, 0x92, 0x19, 0x60, 0x24, 0x18, 0xFC, 0x77, 0x18, 0xBE, 0x99, 0x99, 0x50, + 0x7E, 0x98, 0x7E, 0xF4, 0x9C, 0xD4, 0xD5, 0x98, 0x64, 0x35, 0x91, 0x3B, 0x06, 0x3F, 0x0A, 0x26, + 0x10, 0x90, 0x47, 0xB8, 0x73, 0x86, 0xEC, 0x9B, 0x26, 0x2A, 0x92, 0x66, 0x18, 0x82, 0x86, 0x44, + 0x0B, 0x86, 0x38, 0x02, 0x26, 0x55, 0x19, 0x80, 0xA1, 0x74, 0xD0, 0xC6, 0x8B, 0x7A, 0x23, 0x01, + 0x30, 0x30, 0x33, 0x1F, 0x12, 0x03, 0x01, 0xB6, 0x76, 0xE8, 0xAA, 0xE8, 0xD0, 0x9E, 0xC9, 0x08, + 0xD3, 0x66, 0x5E, 0x24, 0xD7, 0x4A, 0xD6, 0x15, 0x10, 0x30, 0x61, 0x53, 0x1A, 0x02, 0xFF, 0xFB, + 0x92, 0x64, 0xE5, 0x80, 0x06, 0x9A, 0x50, 0x44, 0x26, 0x6F, 0x20, 0x00, 0x93, 0xAA, 0xF8, 0xA9, + 0xC7, 0xB0, 0x00, 0x1A, 0x80, 0xF1, 0x27, 0x59, 0xDD, 0x80, 0x02, 0x48, 0x1D, 0xE3, 0x8B, 0x35, + 0x80, 0x00, 0x04, 0x81, 0xA3, 0xE0, 0xAA, 0x09, 0xD2, 0x0A, 0x96, 0x88, 0x0C, 0x34, 0xB4, 0x1C, + 0x95, 0x6C, 0x5A, 0x8F, 0xA2, 0x57, 0x83, 0x05, 0x80, 0x40, 0x01, 0x81, 0x05, 0xA0, 0x2D, 0x08, + 0xD4, 0x99, 0x96, 0x10, 0x81, 0x83, 0x5A, 0xDA, 0x07, 0xA3, 0x44, 0x3D, 0x33, 0x1F, 0x75, 0xD0, + 0xC9, 0x5B, 0x51, 0xED, 0x6F, 0x35, 0xB5, 0xBC, 0x60, 0x62, 0x04, 0xC2, 0xCD, 0x89, 0x7E, 0xB6, + 0x59, 0x1F, 0xFE, 0x95, 0x81, 0x86, 0x33, 0x38, 0xE7, 0x77, 0x71, 0x84, 0x43, 0x70, 0x4B, 0x36, + 0xDE, 0xB6, 0xB2, 0xB4, 0xD9, 0x29, 0x58, 0x14, 0x83, 0xFF, 0xFF, 0xFF, 0xD3, 0x57, 0xF9, 0xFF, + 0xFF, 0xFE, 0x58, 0x06, 0x8A, 0x73, 0xED, 0x5F, 0xFF, 0xEC, 0x7B, 0x5F, 0xF6, 0xA5, 0x32, 0x43, + 0x7B, 0x15, 0x00, 0x00, 0x00, 0x02, 0x08, 0x0C, 0x4B, 0x72, 0xA9, 0x01, 0xFA, 0x23, 0x00, 0x41, + 0x08, 0x02, 0x05, 0xA4, 0x81, 0x12, 0x67, 0x58, 0xEB, 0xEE, 0x35, 0x42, 0x1D, 0x86, 0x80, 0x60, + 0x8C, 0x15, 0x47, 0xAB, 0xD3, 0x2C, 0x65, 0xF8, 0xC5, 0x62, 0xDF, 0x81, 0x2E, 0x72, 0x6A, 0x8F, + 0x3B, 0x0C, 0x6E, 0x51, 0x4C, 0xAA, 0xB2, 0x87, 0xF3, 0x72, 0xC2, 0xFD, 0xA6, 0x4B, 0x13, 0x34, + 0x8C, 0x60, 0x6B, 0x44, 0x00, 0x3F, 0x7E, 0xFF, 0x7F, 0xEF, 0xD4, 0x37, 0x3E, 0xAE, 0xED, 0xB6, + 0x55, 0x2B, 0x2E, 0xF0, 0x61, 0x9D, 0x0C, 0x21, 0xC9, 0xB8, 0x54, 0xC4, 0x19, 0x2F, 0x76, 0xA6, + 0xE6, 0x33, 0xA7, 0x4B, 0xC7, 0x3E, 0x9E, 0xD3, 0xF7, 0x6E, 0x8B, 0xF2, 0x99, 0xBB, 0xCB, 0xF6, + 0x7B, 0xFF, 0xCC, 0x59, 0xE6, 0x5F, 0xAE, 0x4D, 0x3E, 0x50, 0xFC, 0xBF, 0xFF, 0xFF, 0xFF, 0xFD, + 0xA9, 0x67, 0xFD, 0xDF, 0xFF, 0xE3, 0x2B, 0xB4, 0x14, 0x4E, 0xF6, 0xD4, 0xEC, 0xA9, 0xE3, 0xDE, + 0x7E, 0xAF, 0xFF, 0xD5, 0x30, 0x08, 0x4B, 0x33, 0x08, 0x64, 0x33, 0x1C, 0x54, 0x34, 0x95, 0xE9, + 0x32, 0x10, 0xA7, 0x33, 0x21, 0x88, 0x04, 0xF1, 0x47, 0x79, 0x10, 0x66, 0x36, 0x4E, 0x06, 0xD9, + 0x8B, 0xC6, 0x32, 0xA1, 0xC2, 0x33, 0x88, 0xCD, 0xE3, 0xAC, 0xC1, 0x92, 0xC0, 0xCC, 0xA1, 0x24, + 0xC4, 0x80, 0x38, 0xC3, 0x10, 0x39, 0x38, 0xA5, 0x4A, 0xAF, 0x04, 0xBB, 0x4E, 0x53, 0xC3, 0x52, + 0xEE, 0xFF, 0xBA, 0xEF, 0x26, 0x5A, 0x30, 0xB0, 0xCF, 0x0D, 0x08, 0x79, 0xE4, 0x0A, 0xB0, 0x60, + 0x22, 0x56, 0x47, 0xF6, 0x92, 0xF0, 0x5A, 0x0A, 0x00, 0x71, 0xC2, 0x87, 0x70, 0x4F, 0xE5, 0x71, + 0xCC, 0x66, 0x36, 0x9C, 0x50, 0x23, 0xD9, 0x7B, 0xCB, 0x3E, 0x80, 0x36, 0x83, 0x0C, 0x25, 0xE1, + 0xA8, 0xCF, 0xD1, 0x7D, 0xA4, 0xF2, 0x2B, 0x93, 0xD8, 0x38, 0xD0, 0x4B, 0x4F, 0xB7, 0xCA, 0x5B, + 0xFF, 0xFB, 0x92, 0x64, 0x3E, 0x0B, 0x04, 0xCA, 0x34, 0xCA, 0x07, 0x77, 0x00, 0x00, 0x30, 0x83, + 0x59, 0xDD, 0xE0, 0xA0, 0x00, 0x93, 0x2C, 0xD3, 0x29, 0x0F, 0x73, 0x26, 0x80, 0xC5, 0x98, 0xA7, + 0x74, 0x21, 0x8A, 0x0A, 0x36, 0xBF, 0xFF, 0xFF, 0xFF, 0xF0, 0xB8, 0xF4, 0xED, 0x9E, 0x2C, 0x1B, + 0x5E, 0x93, 0x48, 0x91, 0x09, 0x94, 0x3F, 0x0B, 0xE1, 0x72, 0xBC, 0x4C, 0x31, 0xDA, 0x84, 0xC3, + 0x96, 0x0A, 0x84, 0x82, 0x8A, 0xA4, 0x00, 0x01, 0x10, 0x21, 0xB8, 0x85, 0x13, 0xD8, 0x98, 0xD8, + 0x0B, 0x56, 0xE6, 0x19, 0xC6, 0xA8, 0x7E, 0x3D, 0x79, 0x53, 0x4D, 0x05, 0x06, 0xED, 0x3F, 0xF6, + 0xBA, 0xB6, 0xA4, 0xAF, 0x83, 0x7A, 0x93, 0xFF, 0x28, 0xE2, 0xF5, 0x53, 0xFF, 0xFF, 0xF9, 0x75, + 0xF6, 0xBC, 0x09, 0x0C, 0x01, 0x23, 0x04, 0x22, 0x1A, 0x30, 0x36, 0x06, 0x23, 0x19, 0xA1, 0x7A, + 0x30, 0x5B, 0x06, 0x43, 0x0C, 0x22, 0x29, 0x30, 0x0A, 0x42, 0x63, 0x20, 0x21, 0x99, 0x34, 0x12, + 0x08, 0xEC, 0x65, 0x23, 0x1D, 0x85, 0x8D, 0x50, 0x4A, 0x3E, 0xF9, 0x34, 0xD5, 0x00, 0x13, 0x0B, + 0x8C, 0x49, 0x81, 0x21, 0x5A, 0x33, 0x3D, 0x75, 0x8F, 0x65, 0x6E, 0x7B, 0x79, 0xF7, 0xF7, 0xCF, + 0xF9, 0x96, 0xE8, 0xB2, 0xD8, 0x79, 0x94, 0x79, 0xBE, 0xF1, 0xC9, 0x32, 0x01, 0x41, 0xD2, 0x49, + 0x2E, 0x3B, 0x96, 0x4B, 0x64, 0x0E, 0x30, 0x75, 0x01, 0x96, 0x4D, 0x92, 0x83, 0x8B, 0x1E, 0x0C, + 0x10, 0x09, 0x72, 0x8A, 0x88, 0x3B, 0xE0, 0x52, 0x11, 0x68, 0xA1, 0xC5, 0xCA, 0x8F, 0xE9, 0xF6, + 0xD0, 0x15, 0x5E, 0x82, 0x9B, 0xF5, 0x62, 0x32, 0xCC, 0xD7, 0x7D, 0xBB, 0x1F, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFA, 0xCD, 0x91, 0x97, 0xC6, 0x91, 0x8D, 0xBA, 0x88, 0x50, 0x86, 0x2C, 0x12, 0xDB, 0x27, + 0x69, 0xD9, 0xA1, 0xB4, 0x6D, 0x3E, 0x20, 0x14, 0x2D, 0x80, 0xEF, 0x05, 0x00, 0x80, 0x17, 0x88, + 0x00, 0x84, 0x20, 0x06, 0xE6, 0x99, 0xFD, 0x57, 0x51, 0xF0, 0x49, 0x87, 0x26, 0x60, 0x6D, 0x63, + 0xF4, 0x02, 0x06, 0x1C, 0xF4, 0x4E, 0x77, 0xA7, 0x53, 0xB7, 0x4C, 0xEF, 0xFD, 0xFF, 0xFF, 0x52, + 0x9C, 0x8B, 0x93, 0x38, 0x49, 0x33, 0x86, 0x7F, 0xFF, 0xFE, 0xAD, 0x9E, 0x85, 0x00, 0x40, 0x00, + 0x00, 0x05, 0xCC, 0x25, 0xC6, 0x28, 0xC5, 0x20, 0x0C, 0xCC, 0x70, 0x49, 0x28, 0xC2, 0x40, 0x2C, + 0xCC, 0x78, 0xCA, 0x18, 0xC1, 0xF5, 0x0B, 0x88, 0xA6, 0xE8, 0xC1, 0xE7, 0xE3, 0x88, 0x0E, 0x8C, + 0xB2, 0x01, 0x37, 0xF1, 0xE4, 0xDE, 0x8E, 0x10, 0x40, 0x98, 0x28, 0x87, 0x31, 0xA4, 0xCC, 0xBB, + 0x16, 0xB8, 0xB6, 0x9F, 0x79, 0x3C, 0xDC, 0x16, 0xD4, 0xF7, 0x43, 0x9D, 0x8E, 0x7F, 0xFE, 0x11, + 0xE1, 0xD0, 0xAB, 0x0E, 0x62, 0xBF, 0x14, 0xBA, 0x31, 0x81, 0x45, 0x82, 0x99, 0x90, 0x66, 0x0C, + 0x2B, 0x76, 0x6C, 0xC5, 0xEA, 0x61, 0x82, 0xC6, 0x4C, 0x58, 0x23, 0x28, 0x2C, 0xC6, 0xCB, 0x31, + 0x63, 0x8A, 0xFF, 0xFB, 0x92, 0x64, 0x32, 0x8B, 0x95, 0x27, 0x34, 0xC9, 0xAB, 0xDC, 0xD1, 0xA0, + 0x2E, 0x23, 0xD9, 0xBE, 0x08, 0x26, 0x0E, 0x16, 0x68, 0xD3, 0x20, 0x0F, 0x6F, 0x49, 0xC0, 0xAA, + 0x91, 0x66, 0x50, 0x60, 0x18, 0x1A, 0x11, 0x08, 0x81, 0x0F, 0x44, 0x11, 0x05, 0x1E, 0x9C, 0xD0, + 0x52, 0xF8, 0x64, 0x41, 0x65, 0x8C, 0x10, 0xC0, 0xB8, 0x35, 0x38, 0x5A, 0x11, 0x7B, 0x3A, 0xEB, + 0x2F, 0x61, 0x2D, 0xCD, 0x52, 0xCA, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xB4, 0xDE, 0x34, + 0xC5, 0x8C, 0xD0, 0x96, 0x6A, 0xC3, 0x91, 0x11, 0x4F, 0xD7, 0xF1, 0x45, 0x67, 0xDC, 0x16, 0xE8, + 0xE3, 0x2E, 0x47, 0xB9, 0x97, 0x62, 0x0A, 0x00, 0x04, 0x00, 0x0F, 0x10, 0x00, 0x00, 0x00, 0xEB, + 0xFC, 0xC7, 0x31, 0x4E, 0x94, 0x26, 0x8B, 0x4E, 0xAF, 0xE7, 0xFE, 0x49, 0x98, 0x2C, 0x79, 0xF9, + 0x6B, 0x7B, 0x9D, 0xC4, 0x0E, 0xC9, 0x88, 0x11, 0x13, 0x53, 0x6C, 0xA5, 0x06, 0x69, 0xFF, 0x82, + 0x94, 0xA8, 0x59, 0xCD, 0x30, 0x1E, 0x07, 0x53, 0x18, 0x72, 0xBF, 0x32, 0x40, 0x0F, 0x33, 0x10, + 0x96, 0x45, 0x31, 0x41, 0x11, 0x33, 0x54, 0x20, 0xCF, 0x30, 0x25, 0x29, 0x63, 0x2C, 0x11, 0xFC, + 0x30, 0x2B, 0x06, 0x83, 0x1F, 0x00, 0x41, 0x37, 0xCC, 0x90, 0x7D, 0xC1, 0xAB, 0xCA, 0x08, 0x87, + 0x0D, 0x57, 0x18, 0x1C, 0xAE, 0x22, 0x84, 0x12, 0x1D, 0x0C, 0x35, 0x4A, 0xD6, 0x09, 0x38, 0xD8, + 0x1E, 0x6D, 0x3E, 0x2C, 0x5D, 0x5B, 0xDB, 0x26, 0x5C, 0xFA, 0x09, 0x58, 0x50, 0x9D, 0x1E, 0x0C, + 0xBD, 0x08, 0xC6, 0x80, 0x06, 0xC2, 0x0C, 0x08, 0x5C, 0x2C, 0x18, 0x61, 0x83, 0x66, 0x5E, 0x14, + 0x61, 0x40, 0xA2, 0xC7, 0xC6, 0xE8, 0x9A, 0x5C, 0x98, 0x05, 0x65, 0x09, 0x0F, 0x43, 0x43, 0x0C, + 0x88, 0x16, 0x9C, 0x52, 0x01, 0xDF, 0x16, 0x0A, 0xD8, 0x6E, 0x54, 0x95, 0xAD, 0x10, 0x80, 0x24, + 0x18, 0x60, 0x85, 0x08, 0x93, 0xAB, 0xC4, 0xA9, 0x76, 0x98, 0x86, 0x1A, 0xA8, 0x8D, 0x20, 0x60, + 0xAB, 0x0E, 0xEE, 0xD3, 0x5F, 0xD7, 0xFF, 0xFF, 0xFF, 0xD4, 0x96, 0x57, 0x8E, 0x3F, 0x65, 0x40, + 0x2F, 0x2B, 0x2D, 0x6E, 0x25, 0xEE, 0x69, 0x05, 0xE9, 0x24, 0x07, 0x09, 0x60, 0x6F, 0x9A, 0xF0, + 0x54, 0x2B, 0xB6, 0xCA, 0x96, 0xC6, 0x68, 0x80, 0x09, 0x8E, 0xCE, 0xE4, 0x77, 0xBF, 0xAB, 0xCF, + 0xE8, 0x25, 0xE1, 0x50, 0x4F, 0xFF, 0xF4, 0xF3, 0x75, 0x5B, 0xF3, 0x09, 0xA2, 0xF3, 0x88, 0xEE, + 0x30, 0x2C, 0x12, 0x80, 0xCB, 0x9D, 0xE7, 0x7E, 0xDB, 0xFB, 0xAA, 0x77, 0xF8, 0x7A, 0xD5, 0x22, + 0x25, 0x30, 0x30, 0x03, 0x00, 0xB3, 0x00, 0xA4, 0x33, 0x07, 0x04, 0xC9, 0x9A, 0xD2, 0x28, 0x18, + 0xEE, 0x8B, 0x91, 0x94, 0x88, 0x45, 0x9A, 0x1D, 0x60, 0x16, 0xEC, 0xCA, 0x45, 0x4E, 0x96, 0x44, + 0xC1, 0x8B, 0x0F, 0x10, 0x84, 0xCC, 0x06, 0x32, 0x47, 0x4A, 0xA2, 0xCA, 0xA1, 0x08, 0x50, 0x82, + 0x9A, 0x86, 0x1A, 0x5B, 0xFF, 0xFB, 0x92, 0x64, 0x19, 0x0B, 0x15, 0x06, 0x34, 0xC9, 0x03, 0xDB, + 0xD1, 0x20, 0x2D, 0x86, 0x69, 0x46, 0x28, 0x6A, 0xB4, 0x51, 0xB4, 0xD3, 0x2A, 0xAF, 0x6F, 0x24, + 0x40, 0xBD, 0x9A, 0x65, 0x14, 0x74, 0x89, 0x18, 0xCD, 0x6A, 0xA2, 0xCB, 0xBD, 0x30, 0xF0, 0xBA, + 0x0D, 0xC4, 0x30, 0x04, 0x27, 0x7F, 0xCC, 0x87, 0x02, 0xA7, 0xCA, 0x08, 0x0C, 0x4C, 0x30, 0x70, + 0x54, 0xC5, 0x6B, 0xA9, 0xD4, 0x00, 0x02, 0x60, 0x04, 0xC7, 0xEF, 0xA9, 0xD1, 0x68, 0x05, 0x0A, + 0x84, 0x4A, 0x38, 0x70, 0x0C, 0x71, 0xC3, 0x0A, 0xDC, 0x28, 0x1C, 0xCC, 0x09, 0x33, 0x09, 0x44, + 0x64, 0x1F, 0xD2, 0xC9, 0x92, 0x05, 0x53, 0xB2, 0xD8, 0xA3, 0x9A, 0x46, 0x21, 0x05, 0x98, 0x62, + 0x20, 0x91, 0xC8, 0x0D, 0x56, 0xAE, 0xEF, 0x3E, 0x73, 0xFF, 0xFF, 0xFE, 0x82, 0x5F, 0x25, 0x6A, + 0xFD, 0x77, 0x20, 0x7B, 0x30, 0x5A, 0xAA, 0xA0, 0xDB, 0x1E, 0x92, 0xBF, 0x0D, 0x26, 0x44, 0xD1, + 0xA9, 0x5F, 0x78, 0x0D, 0xC0, 0x8D, 0xF4, 0x10, 0x80, 0x60, 0x01, 0x87, 0xFF, 0xD0, 0x27, 0x18, + 0x69, 0xEE, 0xAA, 0xFA, 0xD5, 0x6F, 0xF1, 0x54, 0xE7, 0x26, 0x61, 0x5F, 0xD2, 0xB9, 0x95, 0x12, + 0xCC, 0x61, 0x95, 0x2A, 0x85, 0x23, 0x87, 0xF3, 0x21, 0x0D, 0x4F, 0x37, 0xFF, 0xFC, 0xD6, 0xF6, + 0x53, 0xDB, 0xA1, 0x5A, 0x82, 0x02, 0x00, 0xF3, 0x06, 0xA1, 0xE3, 0x31, 0x73, 0x0A, 0x43, 0x12, + 0xD4, 0xA6, 0x32, 0x20, 0x02, 0x23, 0x09, 0x60, 0xF1, 0x35, 0x11, 0xF3, 0xBB, 0x5E, 0x01, 0x14, + 0x98, 0x03, 0xE0, 0xEB, 0xC2, 0x1A, 0xC8, 0x91, 0x07, 0x19, 0x0E, 0x25, 0x1C, 0x68, 0x3A, 0x0A, + 0x69, 0x5D, 0x59, 0xD6, 0xCB, 0x9C, 0xD4, 0x65, 0xC1, 0xA7, 0x5A, 0x77, 0xA9, 0x31, 0xA7, 0xAE, + 0x9D, 0xEF, 0x35, 0x01, 0x40, 0x00, 0x70, 0xDC, 0xDA, 0x5C, 0x29, 0xDC, 0x18, 0x76, 0x10, 0xFE, + 0x22, 0xB8, 0xA0, 0xA6, 0xF6, 0x46, 0x20, 0x20, 0xFE, 0x0C, 0x46, 0xC3, 0x00, 0x15, 0x21, 0x52, + 0x85, 0x93, 0x56, 0x90, 0xAE, 0x61, 0xE1, 0xAA, 0xB5, 0x32, 0x56, 0x45, 0xD9, 0x8D, 0x66, 0x71, + 0x02, 0xB9, 0xB5, 0xDC, 0x6E, 0xFF, 0x39, 0xFF, 0xFF, 0xFF, 0xFA, 0xEF, 0x1C, 0x4B, 0xD5, 0xAD, + 0x76, 0xC4, 0x38, 0xDC, 0x1E, 0xFA, 0x19, 0x0D, 0x35, 0xC5, 0xE1, 0xC7, 0xF1, 0xB3, 0x20, 0xDB, + 0x67, 0xB4, 0x01, 0x00, 0x17, 0x2F, 0xFF, 0x73, 0x2C, 0x11, 0xB2, 0x72, 0xA0, 0x5B, 0x15, 0x5A, + 0x5F, 0x42, 0x1F, 0xE8, 0x24, 0x20, 0x83, 0xFA, 0x1D, 0x24, 0x22, 0x81, 0x9F, 0x40, 0x05, 0x3C, + 0x8B, 0x9C, 0xE1, 0xCF, 0x0E, 0x2F, 0xFF, 0xEA, 0x77, 0xE2, 0xFD, 0x5A, 0x10, 0x5B, 0x84, 0x60, + 0xE2, 0xEA, 0x2D, 0xD1, 0x84, 0x00, 0x85, 0x04, 0x1F, 0x39, 0x95, 0x9A, 0x10, 0x99, 0xFB, 0x00, + 0x69, 0x84, 0x10, 0xAF, 0x18, 0xEA, 0xE9, 0xDB, 0xC5, 0x98, 0x28, 0xE9, 0x83, 0x5D, 0x84, 0x3E, + 0x39, 0xAE, 0x0B, 0xA2, 0x35, 0x10, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x0F, 0xB4, 0x8F, 0x34, 0x49, + 0x83, 0xDB, 0xD1, 0x12, 0x31, 0x25, 0xB9, 0x74, 0x1C, 0xC2, 0xC2, 0x51, 0x30, 0xD1, 0x2A, 0x0F, + 0x6F, 0x22, 0x80, 0xAD, 0x19, 0x65, 0x14, 0x04, 0x1D, 0x2B, 0xC0, 0x8B, 0x16, 0x8C, 0x2A, 0x70, + 0x7C, 0x24, 0x4A, 0x07, 0xE5, 0xB4, 0x9D, 0xA6, 0x66, 0x12, 0x07, 0x6A, 0x53, 0x34, 0xFD, 0xB4, + 0xFA, 0x78, 0xB4, 0xAD, 0xE1, 0x5F, 0xCF, 0xB0, 0xA8, 0xA1, 0xB0, 0x52, 0x7B, 0xDC, 0xC3, 0xEB, + 0xAB, 0x7C, 0x78, 0xB4, 0x09, 0xA6, 0x60, 0x34, 0x88, 0x85, 0x9E, 0x53, 0x6A, 0xE0, 0xFA, 0x31, + 0x06, 0x11, 0x34, 0x89, 0x4B, 0xAE, 0x24, 0x44, 0x03, 0x9C, 0xE1, 0x84, 0x50, 0x38, 0x9A, 0x33, + 0x3F, 0x4D, 0xD9, 0x9D, 0x29, 0x7B, 0x6A, 0xC7, 0xE2, 0x6F, 0x67, 0x7B, 0xDF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFD, 0x33, 0xBE, 0x72, 0x1B, 0x89, 0xAF, 0xB6, 0x54, 0xBC, 0xDF, 0xAC, 0xBF, 0xAF, 0x02, + 0xC0, 0x43, 0xBB, 0x56, 0x96, 0xF1, 0xB9, 0x2A, 0x00, 0x60, 0x01, 0x00, 0xFD, 0x7C, 0x32, 0x49, + 0x4E, 0x12, 0x45, 0x26, 0x09, 0x26, 0xE9, 0x6B, 0x3D, 0xD3, 0xEA, 0x2E, 0x1A, 0xBF, 0x8E, 0xD5, + 0x0C, 0x5E, 0x70, 0x9D, 0x60, 0xC1, 0xC0, 0x26, 0x38, 0x11, 0x19, 0x3A, 0xD1, 0xF0, 0xEC, 0x40, + 0x7F, 0xFF, 0xF8, 0x37, 0xAA, 0xFF, 0xC2, 0x43, 0x5A, 0x12, 0x03, 0x43, 0x02, 0x31, 0x78, 0x31, + 0x63, 0x04, 0x13, 0x01, 0x76, 0x2B, 0x35, 0x7A, 0xD3, 0xBD, 0x8E, 0x35, 0x46, 0x70, 0xA3, 0x11, + 0x28, 0xF1, 0x9F, 0xC9, 0x19, 0x84, 0xA1, 0x25, 0x04, 0xD1, 0xD3, 0x05, 0x15, 0x34, 0x2A, 0x18, + 0x1D, 0x8C, 0x18, 0xF9, 0xE3, 0x9B, 0x30, 0x97, 0xC5, 0xE7, 0xE9, 0xF9, 0x16, 0xA7, 0x79, 0x32, + 0x7B, 0x7E, 0x82, 0x55, 0x22, 0x61, 0x02, 0xC1, 0x48, 0xFF, 0x9A, 0xD4, 0x61, 0x4D, 0x94, 0xE8, + 0xB8, 0xA1, 0x52, 0xCF, 0xB9, 0x8C, 0x17, 0x4E, 0xB2, 0x08, 0x86, 0x37, 0x47, 0x11, 0x2A, 0x44, + 0x9A, 0x3D, 0xBC, 0xA0, 0x06, 0x4B, 0xA4, 0x0E, 0xF1, 0x60, 0x42, 0x03, 0x7D, 0xC5, 0x8A, 0xD2, + 0xBF, 0x15, 0x04, 0x30, 0x0A, 0xD6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE3, 0x17, 0xEB, + 0xC1, 0xB0, 0x2B, 0xC8, 0xE3, 0x4C, 0xD3, 0x63, 0xFD, 0x92, 0x3A, 0xED, 0x99, 0x0A, 0x50, 0x10, + 0xD5, 0x9F, 0xF1, 0x40, 0x12, 0x51, 0xA1, 0xE9, 0xAA, 0xC3, 0xBF, 0x68, 0x3C, 0x69, 0xF7, 0xCA, + 0xEE, 0x6D, 0x87, 0x46, 0xA9, 0xFA, 0x9A, 0x45, 0xA0, 0x0C, 0xE8, 0x8A, 0x50, 0x75, 0x46, 0xAD, + 0x6E, 0x50, 0x68, 0xE3, 0xC2, 0xF7, 0xFF, 0xFF, 0x3D, 0xF4, 0xFA, 0x0A, 0x6F, 0x9A, 0x30, 0x08, + 0x28, 0xC5, 0x12, 0x63, 0x46, 0x82, 0x8F, 0x4C, 0x0A, 0x3E, 0xA8, 0x54, 0xCE, 0xCA, 0x53, 0x04, + 0x8A, 0xC8, 0x41, 0xA0, 0xA0, 0xD9, 0x8F, 0x05, 0xA8, 0x28, 0xBB, 0xE0, 0x42, 0x20, 0x7A, 0x87, + 0xA9, 0x04, 0xEC, 0x4B, 0x89, 0x25, 0xAD, 0xE3, 0xFF, 0xFB, 0x92, 0x64, 0x15, 0x0B, 0xB3, 0xBC, + 0x34, 0xCC, 0x83, 0x99, 0x93, 0x70, 0x34, 0x06, 0x58, 0xF4, 0x29, 0x07, 0x5E, 0x0D, 0xD4, 0xD1, + 0x37, 0x0E, 0xE1, 0xAD, 0xC0, 0xE0, 0x96, 0x63, 0x80, 0xD4, 0xAA, 0x48, 0x2E, 0xED, 0x9D, 0xDF, + 0xD7, 0xEB, 0x53, 0x13, 0xD8, 0x6A, 0x62, 0x5C, 0xD6, 0x1F, 0x9B, 0xFF, 0xFA, 0xB7, 0x05, 0x35, + 0x17, 0xF2, 0x07, 0x0B, 0x0A, 0x5E, 0xB3, 0x18, 0x91, 0xA2, 0x91, 0x11, 0x69, 0x18, 0x59, 0x25, + 0x99, 0x40, 0x12, 0x35, 0xDC, 0x22, 0x31, 0x3F, 0x59, 0xFC, 0x3B, 0x8B, 0x7B, 0x00, 0x36, 0xE1, + 0x2B, 0x1C, 0x94, 0x1F, 0xFF, 0xEA, 0x31, 0x99, 0x96, 0x0D, 0xCC, 0xCD, 0xC6, 0xF9, 0xBB, 0x65, + 0x82, 0x90, 0xB1, 0x91, 0x41, 0xB4, 0x32, 0x25, 0xC3, 0x70, 0x00, 0x00, 0x00, 0x28, 0xA8, 0x2C, + 0x37, 0xF8, 0x32, 0x01, 0x8A, 0x0F, 0x12, 0x1A, 0x12, 0x63, 0xF0, 0x74, 0x09, 0x88, 0x01, 0x49, + 0x72, 0x47, 0x0F, 0xD6, 0xBE, 0xBF, 0xF7, 0x7E, 0x90, 0x69, 0x28, 0x43, 0xE7, 0x5B, 0xCF, 0x88, + 0x00, 0x1C, 0x90, 0xF0, 0x8C, 0xFF, 0xFF, 0xD0, 0x01, 0x4B, 0xFF, 0x98, 0x28, 0x70, 0x0C, 0x12, + 0x07, 0x02, 0x0E, 0xC3, 0x18, 0x08, 0x43, 0x04, 0xB1, 0x03, 0x00, 0x05, 0x41, 0x08, 0xD8, 0x81, + 0x03, 0x0C, 0x00, 0x24, 0x91, 0x12, 0x31, 0xD1, 0x59, 0x75, 0xB0, 0x12, 0x60, 0x08, 0x74, 0x01, + 0x55, 0xAB, 0x5D, 0x5A, 0x68, 0x2E, 0x63, 0xF2, 0x0D, 0x63, 0x8E, 0x55, 0x31, 0xB7, 0x6B, 0x0E, + 0x7E, 0x72, 0x38, 0xD4, 0x6F, 0x08, 0x47, 0x33, 0xD6, 0xFA, 0xF2, 0x34, 0x67, 0xC0, 0xBE, 0x8F, + 0xD1, 0x0D, 0x99, 0xB9, 0x74, 0x9C, 0x10, 0xAB, 0x5C, 0x96, 0xDE, 0x10, 0xFE, 0x85, 0x0C, 0xEB, + 0xA6, 0x9C, 0x69, 0x85, 0xC3, 0xAB, 0x05, 0x60, 0x1D, 0x07, 0xFF, 0xFF, 0xD5, 0x5A, 0x27, 0x48, + 0x45, 0x13, 0x27, 0xD4, 0x56, 0x54, 0x5C, 0x12, 0x71, 0x94, 0x27, 0xA8, 0x84, 0x40, 0x22, 0x37, + 0xB6, 0xB0, 0x6F, 0x85, 0xE0, 0x4D, 0x07, 0xD4, 0x39, 0x7C, 0x78, 0x10, 0x7A, 0x57, 0x1D, 0x3C, + 0x8A, 0x08, 0x3D, 0x08, 0x1E, 0xC2, 0xE2, 0x37, 0xF0, 0x46, 0x29, 0xC2, 0x8C, 0x41, 0x8A, 0x43, + 0x01, 0xA8, 0xDB, 0xC4, 0x60, 0x2A, 0x19, 0x17, 0x85, 0xE4, 0x60, 0x5C, 0x20, 0x39, 0xFF, 0xFF, + 0xD0, 0x99, 0xFD, 0x44, 0x6A, 0x00, 0x00, 0x24, 0x00, 0x2F, 0x81, 0x8D, 0x4F, 0x06, 0xC8, 0x0C, + 0x1C, 0xE4, 0xDE, 0x2E, 0x60, 0x32, 0x79, 0x74, 0x48, 0x08, 0x40, 0x07, 0x11, 0x05, 0x8C, 0x34, + 0x20, 0x81, 0x55, 0xAC, 0xBF, 0xAA, 0xD6, 0x48, 0x03, 0x8F, 0x92, 0x96, 0x33, 0x7F, 0xE8, 0xFB, + 0x0F, 0xDF, 0xDF, 0x2F, 0x67, 0x6F, 0x3B, 0x59, 0xE3, 0xFC, 0x96, 0xDB, 0x97, 0x4F, 0xCE, 0xDE, + 0xD7, 0xFC, 0xA2, 0x05, 0x91, 0xCE, 0xA5, 0x9C, 0x00, 0x04, 0x0C, 0x55, 0x86, 0x40, 0x84, 0xFA, + 0x58, 0x42, 0x81, 0xB1, 0x8B, 0x21, 0x5A, 0x2C, 0xC5, 0x49, 0xFF, 0xFB, 0x92, 0x64, 0x2A, 0x8B, + 0x03, 0x5E, 0x33, 0xCE, 0x43, 0x98, 0x6B, 0x72, 0x36, 0x64, 0x49, 0x45, 0x24, 0x4C, 0x76, 0x8D, + 0xD4, 0xD1, 0x3A, 0x8E, 0xE1, 0x4D, 0xC0, 0xCF, 0x17, 0x66, 0xE4, 0x93, 0x09, 0xB8, 0xA9, 0x25, + 0x22, 0xAC, 0x64, 0x01, 0xC1, 0xFF, 0xFF, 0xEA, 0x52, 0x25, 0x23, 0xDD, 0x43, 0xC8, 0x98, 0x4A, + 0x05, 0x19, 0xF1, 0xEA, 0x30, 0x80, 0x00, 0x03, 0x47, 0x77, 0xFB, 0x28, 0xEE, 0x40, 0xE1, 0xC0, + 0xA8, 0xC1, 0xF4, 0x68, 0xF6, 0x55, 0x45, 0xF7, 0x81, 0x8E, 0x71, 0xB1, 0xC5, 0x36, 0xBC, 0xBD, + 0xF3, 0x93, 0x2C, 0x3E, 0xFD, 0xCE, 0x02, 0x7B, 0x46, 0x13, 0xD0, 0x90, 0xB5, 0xFF, 0x02, 0x86, + 0x9D, 0x3A, 0x8A, 0x89, 0x49, 0xFF, 0xFD, 0x67, 0xE4, 0x0B, 0xC9, 0x80, 0x60, 0x43, 0x13, 0x0A, + 0x4A, 0xB3, 0x20, 0x04, 0x73, 0x08, 0x29, 0x73, 0x14, 0xC5, 0x93, 0x14, 0x82, 0xE0, 0x70, 0x24, + 0x60, 0xF0, 0x50, 0xA6, 0xE6, 0x20, 0x00, 0xAB, 0xD5, 0xAD, 0x15, 0x40, 0x18, 0x92, 0x6D, 0xB7, + 0xED, 0x41, 0xB3, 0xE7, 0x76, 0x59, 0x76, 0x02, 0x7D, 0xE8, 0xE1, 0xDD, 0xD7, 0xBF, 0x49, 0x7E, + 0xFC, 0xB2, 0xE7, 0xE5, 0x5E, 0x28, 0xFE, 0x5B, 0x95, 0x5E, 0xDD, 0x47, 0x82, 0x6D, 0xBB, 0xD3, + 0xA7, 0xC3, 0x63, 0x23, 0x74, 0xA9, 0x9A, 0xAF, 0x82, 0x69, 0x15, 0x48, 0x9E, 0x4C, 0x6A, 0x12, + 0x49, 0x36, 0xF1, 0xA4, 0xE9, 0xF9, 0x7D, 0x9F, 0xD6, 0x88, 0x14, 0xB3, 0xFF, 0xFF, 0xF3, 0x18, + 0x8C, 0x9C, 0x93, 0xAC, 0x32, 0x26, 0x0B, 0x83, 0xC8, 0x98, 0x60, 0x00, 0x78, 0x07, 0x00, 0xE7, + 0xF7, 0xFB, 0x90, 0xFE, 0xA5, 0x98, 0x55, 0xC8, 0x56, 0x5C, 0x7C, 0xEF, 0x1E, 0xEF, 0x52, 0xCA, + 0x24, 0x69, 0x8A, 0xF2, 0xD7, 0x96, 0xAD, 0xFD, 0xA9, 0xD5, 0xE9, 0x64, 0xCC, 0x30, 0x31, 0xE4, + 0x4F, 0x10, 0x52, 0xF1, 0xF2, 0xE3, 0x13, 0xFF, 0xFF, 0xF5, 0x41, 0x52, 0xD9, 0x4A, 0x00, 0x80, + 0x03, 0x65, 0x30, 0x23, 0xFC, 0xC2, 0x61, 0x03, 0x81, 0x33, 0x8E, 0x26, 0x0E, 0x31, 0xD9, 0x60, + 0xC0, 0x80, 0xA3, 0x13, 0x92, 0xD1, 0xFC, 0xCB, 0xE2, 0x12, 0x60, 0x12, 0xB0, 0x0A, 0x02, 0xD9, + 0xAB, 0x09, 0x6A, 0x64, 0x24, 0xB7, 0x7B, 0x54, 0xF6, 0xE3, 0x32, 0xFB, 0x58, 0xDF, 0xD5, 0x36, + 0x39, 0x47, 0x32, 0xBB, 0x77, 0x55, 0xE4, 0xF2, 0x77, 0x29, 0xDD, 0x8B, 0xD5, 0x85, 0x4A, 0x3E, + 0x00, 0xC9, 0x0C, 0x98, 0x88, 0x66, 0x5B, 0x72, 0xF9, 0x35, 0x84, 0x8C, 0x58, 0x26, 0xDD, 0x99, + 0x4F, 0x36, 0x35, 0x62, 0x61, 0x8F, 0xFB, 0x5F, 0x87, 0x9A, 0x75, 0xA8, 0x10, 0x7F, 0xFF, 0xFF, + 0x00, 0xD4, 0x0A, 0x3B, 0xD0, 0x48, 0x44, 0x58, 0x18, 0x2D, 0x81, 0x08, 0x6B, 0xA0, 0x00, 0x00, + 0xE0, 0x00, 0x11, 0xB0, 0x41, 0x0F, 0x04, 0x11, 0x08, 0x4E, 0xFB, 0xD2, 0x14, 0x5E, 0xCF, 0x8C, + 0xF6, 0x8B, 0x10, 0xD1, 0x18, 0xAE, 0x42, 0x02, 0x4C, 0x51, 0x85, 0xCF, 0xFF, 0xFB, 0x92, 0x64, + 0x47, 0x0E, 0xE3, 0x62, 0x34, 0x4E, 0xAB, 0x98, 0x2B, 0x70, 0x38, 0x23, 0xF9, 0x71, 0x1C, 0xC9, + 0x4C, 0x0C, 0xFC, 0xCB, 0x42, 0x6E, 0x3D, 0x6F, 0x88, 0xDC, 0x10, 0xE6, 0xC8, 0x90, 0xA6, 0x08, + 0xD1, 0x05, 0x87, 0x82, 0x44, 0xE3, 0x6A, 0xA6, 0x30, 0xA0, 0x88, 0xAF, 0x89, 0xA6, 0x17, 0x68, + 0x39, 0xFD, 0x2D, 0xE8, 0x43, 0x83, 0x51, 0x80, 0x20, 0x93, 0x03, 0x19, 0xCC, 0x8A, 0x06, 0x30, + 0xFD, 0x80, 0xC3, 0x80, 0x60, 0xA9, 0xED, 0x0A, 0x8C, 0x14, 0x1A, 0x2D, 0x21, 0x88, 0x02, 0xCA, + 0xAA, 0xAE, 0xDA, 0x73, 0x1D, 0x70, 0xD4, 0x9C, 0x49, 0xE4, 0x81, 0x11, 0xAD, 0x8D, 0x82, 0xB2, + 0xED, 0x83, 0x78, 0x72, 0xC2, 0xB2, 0x24, 0x18, 0x76, 0x5B, 0x30, 0x1A, 0x91, 0xB9, 0x60, 0x5F, + 0x9A, 0x09, 0xFF, 0x19, 0x8E, 0x38, 0xE8, 0x06, 0x42, 0x9C, 0x7C, 0xB9, 0x86, 0xD9, 0x72, 0x52, + 0x5C, 0xC7, 0x43, 0xC9, 0x23, 0x1B, 0x4E, 0x55, 0xC9, 0x88, 0xAA, 0x43, 0xAA, 0x1F, 0xFF, 0xFF, + 0xFE, 0x6E, 0x7D, 0xE7, 0xC3, 0x84, 0xD2, 0xD3, 0x97, 0x0F, 0xB6, 0xB8, 0xE1, 0xD5, 0x4C, 0x06, + 0xB7, 0x17, 0x47, 0x44, 0xF0, 0x11, 0x9C, 0x20, 0x49, 0x29, 0x87, 0x87, 0x48, 0x1E, 0x92, 0x39, + 0xF4, 0x7D, 0x43, 0xB4, 0x77, 0x04, 0xD9, 0x92, 0x72, 0x51, 0x01, 0x79, 0x1A, 0xB0, 0xF1, 0xCA, + 0x33, 0xAB, 0x0E, 0x2C, 0xB0, 0x91, 0x19, 0xC4, 0x89, 0xC9, 0x4A, 0xB4, 0x93, 0x64, 0x32, 0x58, + 0xAF, 0xF2, 0x12, 0xFB, 0x24, 0x6A, 0x00, 0x34, 0x0A, 0x71, 0xA4, 0x12, 0x90, 0x30, 0x35, 0xB8, + 0x3E, 0x14, 0x2E, 0xA6, 0x7D, 0xAF, 0x26, 0xF6, 0xC6, 0x66, 0x23, 0x66, 0xAE, 0xF6, 0x12, 0x63, + 0x63, 0x94, 0x54, 0x2A, 0x76, 0xEC, 0x68, 0x0E, 0xD2, 0xE2, 0xC1, 0x16, 0x09, 0x2A, 0x64, 0x18, + 0xA9, 0xCA, 0x24, 0xDF, 0x9D, 0xEF, 0x19, 0x0F, 0xE4, 0x62, 0x85, 0x36, 0x50, 0x27, 0x81, 0xF0, + 0xA1, 0x00, 0xF0, 0x7B, 0x0E, 0x71, 0x8A, 0x48, 0x2C, 0x84, 0x23, 0xC6, 0x19, 0xC8, 0x01, 0x80, + 0x0C, 0x90, 0x98, 0x0B, 0x81, 0xE2, 0x0D, 0x71, 0xCC, 0x2F, 0x43, 0xFC, 0xCB, 0x16, 0x55, 0xD8, + 0x9C, 0x21, 0x48, 0x8A, 0x45, 0xE4, 0xAA, 0x8D, 0x78, 0x60, 0xD7, 0xFF, 0xFF, 0xFF, 0xFB, 0x2E, + 0x09, 0x63, 0x3C, 0xA6, 0x12, 0x44, 0xC5, 0x90, 0xF2, 0x40, 0x7E, 0xA3, 0x2D, 0x7F, 0x1C, 0xE7, + 0xD9, 0x61, 0xFC, 0xFD, 0x12, 0x18, 0x97, 0x1F, 0x15, 0xB4, 0x95, 0xBC, 0xBB, 0x79, 0xF5, 0xA4, + 0xD8, 0x9F, 0xAC, 0xAF, 0xFA, 0x2C, 0xDB, 0x3E, 0x37, 0xAA, 0x4A, 0x24, 0xCC, 0x18, 0xC9, 0x74, + 0x27, 0xCA, 0x90, 0x09, 0x12, 0x64, 0xD1, 0x0A, 0x39, 0xE9, 0xCD, 0x4A, 0x92, 0xC9, 0x85, 0x7F, + 0x78, 0xA9, 0x72, 0xE4, 0x2A, 0x20, 0x1F, 0x61, 0x47, 0x81, 0x17, 0x81, 0x99, 0xCD, 0xF0, 0x33, + 0x39, 0x38, 0xF9, 0x82, 0x38, 0x97, 0x48, 0xF3, 0x19, 0xA5, 0xC2, 0xC4, 0xC4, 0x10, 0xFF, 0xFB, + 0x92, 0x64, 0x64, 0x0A, 0x73, 0xD5, 0x33, 0x4F, 0x93, 0x78, 0x7A, 0x10, 0x34, 0x64, 0x29, 0xF0, + 0x05, 0xA9, 0x00, 0x0D, 0x80, 0xCD, 0x46, 0xAD, 0x3C, 0xED, 0xD0, 0xD0, 0x12, 0x27, 0xD4, 0x90, + 0x99, 0xC2, 0xC6, 0x87, 0x8A, 0x80, 0x5E, 0x6C, 0x27, 0x33, 0x7D, 0x5D, 0x59, 0x57, 0x48, 0x0C, + 0x7A, 0xB3, 0x5B, 0x15, 0xA6, 0x76, 0xCC, 0xDA, 0xB2, 0xC0, 0x84, 0x03, 0x21, 0x2A, 0x22, 0xC2, + 0xE6, 0x34, 0xDB, 0x11, 0x59, 0x6A, 0xB1, 0xFA, 0x5B, 0xC1, 0xB6, 0x76, 0x04, 0x18, 0xBA, 0x08, + 0xC2, 0xE0, 0xD2, 0x74, 0xBB, 0x19, 0x63, 0x58, 0xFA, 0x6A, 0x3B, 0x0D, 0x75, 0x72, 0xB2, 0xD0, + 0x86, 0x23, 0x16, 0x24, 0xDF, 0xFA, 0x05, 0x99, 0x94, 0x17, 0x8D, 0x02, 0xA3, 0x72, 0x63, 0xC2, + 0xA6, 0x53, 0xC6, 0x83, 0x44, 0x83, 0x36, 0x84, 0xA2, 0xF0, 0x36, 0xCF, 0x4C, 0xC1, 0x34, 0x42, + 0xC7, 0xD5, 0x6B, 0xAD, 0x51, 0x2D, 0xDD, 0x83, 0xFF, 0xDF, 0x83, 0xB3, 0x0D, 0x40, 0x95, 0x89, + 0x67, 0xCE, 0xFC, 0x42, 0xFE, 0xC2, 0x88, 0x12, 0xB1, 0x93, 0xA0, 0xAC, 0xD4, 0x52, 0x5F, 0x8B, + 0x53, 0xA3, 0xF9, 0x54, 0x80, 0x83, 0x48, 0x0E, 0x6C, 0x01, 0x80, 0x06, 0x60, 0xD3, 0xE1, 0x62, + 0x61, 0x13, 0x28, 0x40, 0xA0, 0x16, 0xC0, 0x3A, 0x38, 0xC2, 0x76, 0x8E, 0xD4, 0x74, 0x28, 0x6C, + 0xC1, 0x0C, 0x08, 0xF0, 0x89, 0x18, 0x40, 0x17, 0x1E, 0x9F, 0xBC, 0xD8, 0x22, 0x78, 0x72, 0x23, + 0x56, 0x83, 0xB5, 0xED, 0x50, 0xFD, 0xCE, 0xEE, 0x6A, 0x5C, 0xF0, 0x34, 0xFA, 0x80, 0x60, 0x70, + 0x10, 0x32, 0x25, 0xC4, 0x58, 0x53, 0xBA, 0xDC, 0x61, 0x59, 0xE0, 0xF4, 0xB5, 0x95, 0xA8, 0x5F, + 0x55, 0x04, 0x5C, 0x10, 0xF3, 0x29, 0x65, 0xB7, 0x20, 0xB5, 0xF6, 0xB0, 0xED, 0xEB, 0x38, 0x9E, + 0x93, 0xAE, 0xD7, 0xD2, 0xF4, 0x1B, 0x85, 0x18, 0x4F, 0xFF, 0xFD, 0x9C, 0x0C, 0xC0, 0xA2, 0x20, + 0x34, 0x00, 0x91, 0x22, 0x07, 0x6D, 0xC1, 0x93, 0x6D, 0xD4, 0x80, 0x31, 0x34, 0xA5, 0x2D, 0x8A, + 0x14, 0x28, 0x59, 0x84, 0x9A, 0x9F, 0x4C, 0xD6, 0x34, 0x51, 0xC8, 0x2B, 0x8B, 0x68, 0x71, 0x41, + 0xFA, 0xA9, 0x61, 0x19, 0x1F, 0xF0, 0x03, 0x8E, 0xA3, 0x50, 0x1B, 0x1A, 0xC3, 0x01, 0xD3, 0x56, + 0xA9, 0x06, 0xAA, 0xD2, 0xA8, 0x9C, 0x9F, 0xFD, 0x0C, 0x72, 0x83, 0x3A, 0x8A, 0x2D, 0xED, 0x3B, + 0x24, 0x01, 0x01, 0xE0, 0x11, 0x09, 0xB4, 0x30, 0x6A, 0x60, 0x94, 0x70, 0xD2, 0x4C, 0x1A, 0xD2, + 0x39, 0x48, 0xC5, 0x23, 0x94, 0x80, 0x14, 0x94, 0x02, 0x3B, 0xA6, 0x5C, 0x2F, 0x9B, 0x86, 0xA1, + 0xCE, 0x6E, 0xFD, 0x4E, 0x51, 0x57, 0xA7, 0xE4, 0xDF, 0x72, 0xCB, 0x2C, 0xA1, 0xB8, 0xCA, 0x61, + 0x83, 0x0E, 0x2D, 0x78, 0x2D, 0x5C, 0x30, 0x58, 0xAC, 0x45, 0xCE, 0xBB, 0x66, 0xB2, 0x0E, 0x31, + 0x50, 0x5A, 0x1B, 0xC5, 0x61, 0x42, 0x73, 0x14, 0x87, 0xAD, 0x3E, 0x10, 0xB4, 0xA9, 0x61, 0x8C, + 0xFF, 0xFB, 0x92, 0x64, 0x7B, 0x8B, 0xF3, 0x7C, 0x33, 0x51, 0x2B, 0x62, 0x37, 0x00, 0x36, 0xA5, + 0x99, 0x80, 0x25, 0x02, 0x6E, 0x4D, 0x48, 0xCB, 0x44, 0x0E, 0x60, 0xED, 0xC8, 0xD8, 0x96, 0xA5, + 0xC0, 0x90, 0x2C, 0x28, 0xF1, 0xB3, 0x45, 0x21, 0x70, 0x1F, 0x37, 0x34, 0xD4, 0x7F, 0xFF, 0x1C, + 0x38, 0x6A, 0x60, 0xD0, 0x74, 0x1C, 0xB0, 0xBC, 0x74, 0x95, 0xC4, 0x51, 0x88, 0xA2, 0x6D, 0x94, + 0x0E, 0x5B, 0x8D, 0x2B, 0xB6, 0xB4, 0x80, 0x59, 0xDD, 0x71, 0xA0, 0x50, 0x43, 0xAD, 0xC8, 0x7F, + 0x13, 0x8D, 0x20, 0x96, 0x4F, 0xF4, 0xC7, 0x72, 0xE1, 0x40, 0x73, 0xA2, 0xCE, 0xCA, 0x72, 0x82, + 0xC2, 0x59, 0x0E, 0x3D, 0x97, 0x9B, 0xF1, 0xDC, 0xC4, 0x19, 0xFF, 0xFF, 0xFF, 0x11, 0xA6, 0x42, + 0x3C, 0xA0, 0x0E, 0xBA, 0x00, 0x02, 0x00, 0x03, 0x00, 0x25, 0x21, 0x50, 0x18, 0xF1, 0x5C, 0x44, + 0x43, 0x33, 0x30, 0x00, 0x02, 0x14, 0x35, 0x18, 0x4C, 0xC6, 0x22, 0x13, 0xA9, 0x8D, 0x0C, 0x1C, + 0x05, 0x6F, 0x47, 0x80, 0xC1, 0x10, 0xA4, 0x29, 0x04, 0x02, 0x11, 0x15, 0xEF, 0x8B, 0x43, 0x36, + 0x25, 0x56, 0xE6, 0x6F, 0x4F, 0x63, 0x9E, 0x56, 0x2F, 0xFF, 0xFD, 0x57, 0x66, 0x85, 0x1E, 0x43, + 0x8E, 0x5A, 0x96, 0xFD, 0x9E, 0xB1, 0x1E, 0xC7, 0x75, 0xBC, 0x63, 0x8E, 0xD2, 0x72, 0x85, 0x48, + 0x9D, 0xED, 0x39, 0x33, 0xA0, 0x9E, 0x69, 0xEA, 0x85, 0xAB, 0x96, 0xDE, 0x3E, 0xCF, 0xA1, 0xC9, + 0x43, 0xFD, 0xF9, 0x69, 0xFF, 0xF8, 0x75, 0x16, 0xA0, 0x2A, 0x29, 0x06, 0x45, 0x75, 0x3A, 0x81, + 0x09, 0xA0, 0x00, 0x00, 0xC0, 0xA0, 0x26, 0x40, 0x5A, 0x8F, 0x9C, 0x5C, 0x54, 0xD4, 0x7D, 0x5D, + 0xBC, 0x60, 0x70, 0x49, 0x7C, 0x80, 0xFA, 0x9A, 0x43, 0x2A, 0x36, 0x8A, 0x86, 0x28, 0xD8, 0xA8, + 0xC1, 0xB0, 0x3D, 0x34, 0x23, 0x38, 0xFF, 0xF3, 0x3F, 0xFA, 0x1F, 0x34, 0x9B, 0xA1, 0xAE, 0xE5, + 0x16, 0xA7, 0x13, 0xFE, 0xBB, 0x31, 0x60, 0x62, 0x52, 0x42, 0x2D, 0x12, 0x49, 0x95, 0x00, 0xA6, + 0x88, 0x02, 0x0A, 0x88, 0xCC, 0x92, 0x7A, 0x30, 0x40, 0xF4, 0xE7, 0x0A, 0x43, 0x0F, 0x83, 0xC1, + 0x80, 0xC0, 0x50, 0xCC, 0xC9, 0x02, 0xB0, 0xC1, 0x5A, 0xBF, 0x08, 0x05, 0x2B, 0x6F, 0x2C, 0x9F, + 0xBD, 0x6F, 0x3A, 0xD4, 0x94, 0xB4, 0x73, 0x7F, 0xDC, 0x3F, 0x9A, 0xCA, 0x19, 0x76, 0x40, 0x82, + 0x08, 0x3A, 0xE5, 0x7D, 0x1F, 0xAC, 0xA8, 0x69, 0x79, 0xBC, 0xA2, 0x25, 0xFE, 0x05, 0x28, 0x58, + 0x0C, 0x81, 0xA3, 0xD2, 0x72, 0xC3, 0x60, 0x91, 0x41, 0x6E, 0x7B, 0x5F, 0x65, 0x2D, 0x2E, 0x66, + 0x97, 0x8F, 0xFF, 0xFF, 0x51, 0xE2, 0xB1, 0x50, 0xFC, 0x83, 0x13, 0xCA, 0xE3, 0xC0, 0x80, 0x23, + 0x06, 0x01, 0xDC, 0x28, 0x3E, 0xDF, 0xFE, 0x2A, 0x14, 0xAE, 0x8D, 0x42, 0xB9, 0x47, 0xCF, 0x9D, + 0x88, 0x06, 0x77, 0x07, 0xD3, 0x27, 0x59, 0xCE, 0x8F, 0xE2, 0xF7, 0xD6, 0xA5, 0x49, 0x85, 0x43, + 0x60, 0xA1, 0xFF, 0xFB, 0x92, 0x64, 0x97, 0x0B, 0x73, 0x68, 0x33, 0x51, 0x4B, 0x98, 0x13, 0x72, + 0x35, 0x86, 0x19, 0xC7, 0x04, 0x07, 0x26, 0x0D, 0x34, 0xD3, 0x45, 0x0E, 0x60, 0xAD, 0xC0, 0xCA, + 0x16, 0xE6, 0xA0, 0x55, 0x9E, 0xC9, 0x32, 0xA8, 0x23, 0x06, 0x8E, 0xFE, 0x9F, 0xFD, 0x18, 0xE7, + 0x22, 0x63, 0x4F, 0x6B, 0xEA, 0xC5, 0x05, 0x95, 0x08, 0x95, 0x40, 0x4B, 0xC9, 0x3E, 0x67, 0xEC, + 0x64, 0x01, 0x67, 0x2D, 0xC2, 0x61, 0x64, 0xA7, 0xDB, 0x78, 0x7C, 0xA0, 0x06, 0x06, 0x88, 0x00, + 0x16, 0x57, 0x47, 0x3E, 0x2A, 0xD3, 0x41, 0xE5, 0x59, 0x8B, 0x62, 0x5F, 0x02, 0x64, 0xD8, 0xBB, + 0x11, 0x96, 0xD7, 0xB9, 0x29, 0x87, 0x2D, 0x4F, 0xDB, 0xBB, 0xC6, 0x78, 0xB2, 0xD2, 0x19, 0x65, + 0x3E, 0x88, 0x0B, 0x62, 0x8C, 0xBE, 0x57, 0x8D, 0x05, 0x79, 0x99, 0x52, 0x81, 0x80, 0x1A, 0xCF, + 0x5B, 0x88, 0x90, 0x57, 0x63, 0xDB, 0x6B, 0x25, 0x95, 0x1B, 0x69, 0x0A, 0xA8, 0xC4, 0xD6, 0x8D, + 0x34, 0x8F, 0x9F, 0xE6, 0x27, 0xFF, 0xA9, 0xA8, 0x3E, 0x2A, 0x55, 0x1D, 0xB6, 0xAA, 0x50, 0x52, + 0x18, 0x1B, 0x0C, 0x30, 0x04, 0x00, 0x18, 0x5D, 0x02, 0x6F, 0xFF, 0xE9, 0xF3, 0xCD, 0x6D, 0x98, + 0x23, 0x5F, 0xC1, 0x02, 0x15, 0x3D, 0xC1, 0x1A, 0x06, 0xBF, 0xE1, 0xFB, 0x62, 0x24, 0xB6, 0x59, + 0x4B, 0x3C, 0x7E, 0xD1, 0x9C, 0x6E, 0xD9, 0x1A, 0x84, 0x48, 0x9A, 0xA5, 0xAB, 0xFF, 0xFA, 0xB9, + 0x3F, 0xEC, 0x10, 0x2B, 0x23, 0xFD, 0x46, 0x5D, 0x1C, 0x88, 0x10, 0x0F, 0x32, 0xE0, 0x50, 0x00, + 0x0D, 0x00, 0x9B, 0x94, 0xD8, 0xC5, 0x51, 0xC2, 0x00, 0x89, 0x85, 0x30, 0xA7, 0x5B, 0x1C, 0xAB, + 0x30, 0x84, 0x32, 0x5B, 0x31, 0x44, 0x70, 0x90, 0xC0, 0x2E, 0xC4, 0xE1, 0x7A, 0xD7, 0xBC, 0x92, + 0x37, 0x75, 0xAF, 0xD7, 0x8C, 0xC5, 0xAA, 0xC3, 0x92, 0x88, 0x4B, 0xF0, 0xE0, 0x45, 0xEB, 0x35, + 0x44, 0xAA, 0x12, 0x10, 0x26, 0x48, 0x4B, 0x66, 0x29, 0x21, 0x2D, 0x8D, 0x47, 0x1F, 0x3C, 0xA5, + 0x0F, 0x72, 0xF2, 0x04, 0x8D, 0x1D, 0x52, 0x11, 0x81, 0x2C, 0x66, 0xDF, 0x3F, 0x95, 0x3D, 0x2F, + 0x1A, 0xD5, 0x64, 0xF0, 0x63, 0x62, 0xEF, 0x7F, 0xC7, 0x4F, 0xFF, 0xFE, 0xAC, 0x10, 0xF6, 0xD5, + 0xCA, 0x0E, 0x20, 0xE0, 0xD1, 0x8A, 0x67, 0xB7, 0xFF, 0x80, 0x09, 0xCF, 0x1B, 0x1E, 0x54, 0xA0, + 0xA8, 0xAC, 0xE6, 0xA1, 0x94, 0x42, 0x8D, 0x90, 0x90, 0xB8, 0xEE, 0x7F, 0x01, 0x1B, 0xE0, 0xF4, + 0x31, 0x1E, 0x7C, 0xA5, 0x61, 0x41, 0x19, 0xAC, 0xF4, 0x95, 0x89, 0xA5, 0x42, 0x97, 0x7F, 0xFF, + 0x91, 0xBF, 0xF1, 0x94, 0x6A, 0xB7, 0x95, 0xEE, 0x61, 0xD5, 0x02, 0x23, 0xA2, 0x81, 0xC1, 0x41, + 0xC9, 0x83, 0x01, 0x06, 0x2B, 0x37, 0xCA, 0x4C, 0x0A, 0xBE, 0x01, 0x50, 0x4C, 0xF4, 0x8D, 0x3E, + 0x68, 0x00, 0x1C, 0x2A, 0x02, 0x16, 0x07, 0x82, 0xA6, 0x00, 0x0A, 0x99, 0xB8, 0x00, 0x90, 0x65, + 0x01, 0x06, 0xA6, 0xF5, 0xFF, 0xFB, 0x92, 0x64, 0xB6, 0x8F, 0xD3, 0x65, 0x34, 0xD0, 0x03, 0x78, + 0x3B, 0x70, 0x35, 0x06, 0x59, 0xA2, 0x1D, 0x22, 0x6E, 0xCD, 0x94, 0xD3, 0x40, 0x0E, 0x60, 0xED, + 0xC0, 0xD0, 0x1A, 0x65, 0xC0, 0x24, 0x89, 0xF0, 0x51, 0x44, 0xE9, 0xE5, 0xF1, 0x2C, 0x65, 0x17, + 0x66, 0xA4, 0x2C, 0x22, 0x3E, 0xFD, 0x43, 0xF2, 0x35, 0x32, 0x4F, 0x04, 0x19, 0x2B, 0x05, 0xAB, + 0xA6, 0x9E, 0xFD, 0x51, 0xB4, 0x08, 0x32, 0x2A, 0xFC, 0xD8, 0x3F, 0x4C, 0x94, 0x79, 0x04, 0x16, + 0x32, 0xDC, 0x1F, 0xE9, 0xC5, 0x8B, 0xCA, 0x8F, 0x39, 0x98, 0x89, 0x12, 0x1C, 0x87, 0xB8, 0xCF, + 0xD1, 0x85, 0x04, 0x0C, 0x2E, 0xF5, 0xFF, 0xFC, 0x49, 0x39, 0x8F, 0x46, 0xA3, 0x14, 0x38, 0x42, + 0x0F, 0x07, 0xD8, 0x2B, 0xFF, 0xF3, 0x84, 0x95, 0xA9, 0x97, 0x36, 0xEF, 0x63, 0xD6, 0x5A, 0x8A, + 0x5D, 0x66, 0xC8, 0x44, 0xE1, 0xDA, 0xF9, 0x32, 0x39, 0x23, 0x1E, 0x51, 0x43, 0xFB, 0x67, 0x66, + 0x60, 0x13, 0xC0, 0xCE, 0x1A, 0xA4, 0x30, 0x75, 0x90, 0x05, 0x1D, 0xFF, 0xE0, 0xC1, 0x9F, 0xF6, + 0x94, 0xB2, 0xFD, 0x03, 0xCE, 0xA2, 0x20, 0x46, 0x80, 0x0A, 0x28, 0xAF, 0xCD, 0x3E, 0x06, 0x30, + 0x18, 0x10, 0x59, 0x22, 0x24, 0x5F, 0x25, 0x58, 0x0B, 0x5F, 0x4C, 0x40, 0x66, 0x38, 0x03, 0xF0, + 0x58, 0x02, 0x0A, 0x43, 0x8B, 0x14, 0x06, 0x45, 0xC6, 0xFC, 0x1B, 0x3F, 0xE2, 0xFA, 0xBF, 0x1A, + 0x81, 0x23, 0xF4, 0x79, 0xBF, 0x39, 0x65, 0x08, 0xC2, 0x2B, 0x1E, 0x76, 0x9F, 0x89, 0x2C, 0xFD, + 0xE5, 0x9B, 0x03, 0x80, 0xD0, 0xC9, 0x23, 0x32, 0x3A, 0xED, 0x37, 0x4F, 0x9B, 0x57, 0x82, 0x99, + 0x63, 0x38, 0x33, 0x8D, 0x8B, 0x08, 0xC4, 0xC9, 0x18, 0x28, 0xF1, 0x20, 0x5C, 0xE3, 0xEA, 0x24, + 0xEA, 0xCA, 0x63, 0xB3, 0x99, 0x5C, 0xA3, 0xF2, 0xB7, 0x26, 0x4C, 0xD7, 0xFF, 0xFC, 0xC3, 0x4F, + 0x26, 0x12, 0x12, 0x26, 0x5A, 0x59, 0xD5, 0x42, 0x82, 0x28, 0xD1, 0xBE, 0x2D, 0x8D, 0xE1, 0x8E, + 0x75, 0x66, 0xA4, 0x7A, 0x21, 0x60, 0x9F, 0x7F, 0x8D, 0xE7, 0x1B, 0x7B, 0x74, 0x6B, 0x63, 0x27, + 0x6A, 0x9D, 0x14, 0x89, 0x42, 0x40, 0xA0, 0xEA, 0x56, 0xB1, 0x37, 0x04, 0x2C, 0x4A, 0xDF, 0xFE, + 0x82, 0x9B, 0x3A, 0x3D, 0x4B, 0xBF, 0xFF, 0xFA, 0x6E, 0xA5, 0x9B, 0x92, 0x66, 0x62, 0x32, 0x79, + 0x0B, 0x80, 0xC6, 0x06, 0x09, 0x86, 0xD0, 0x1B, 0x04, 0x06, 0x19, 0x82, 0x6D, 0x80, 0x90, 0x50, + 0x62, 0x6B, 0x68, 0x62, 0xA9, 0x46, 0x63, 0x59, 0x30, 0x6B, 0x8D, 0x2E, 0x61, 0x40, 0x0A, 0x62, + 0x62, 0x6A, 0x66, 0x30, 0x1E, 0x60, 0x30, 0xF8, 0x6B, 0xAD, 0x1A, 0x1C, 0xBF, 0x98, 0x9C, 0x18, + 0x81, 0x80, 0xB1, 0x90, 0x63, 0xC1, 0x11, 0xB4, 0x50, 0x23, 0x35, 0x50, 0xC6, 0x2E, 0xFB, 0xC0, + 0x32, 0xB5, 0x02, 0x84, 0xA1, 0xD0, 0x14, 0xB1, 0x7C, 0xB2, 0x42, 0xF7, 0x01, 0x56, 0x00, 0xA5, + 0x9B, 0x79, 0x00, 0x13, 0x69, 0xDA, 0xFF, 0xFB, 0x92, 0x64, 0xD4, 0x06, 0xF3, 0xA6, 0x34, 0xD0, + 0x8B, 0x8F, 0x3E, 0x10, 0x35, 0x46, 0xA9, 0x10, 0x05, 0x85, 0x6C, 0x0E, 0x68, 0xD3, 0x42, 0xAE, + 0x60, 0xED, 0xD0, 0xD2, 0x1A, 0xA2, 0x80, 0x07, 0xB5, 0xA0, 0x24, 0x11, 0x29, 0x84, 0x83, 0x47, + 0x50, 0xC5, 0x12, 0x93, 0xD8, 0x1A, 0x90, 0xC8, 0x0E, 0x22, 0x4A, 0x68, 0x42, 0x45, 0x8C, 0xD9, + 0xB0, 0xE5, 0xE5, 0x44, 0x06, 0x60, 0xE2, 0x4A, 0x22, 0x43, 0x04, 0x4C, 0x68, 0x71, 0xEE, 0x89, + 0x3C, 0xED, 0xC5, 0xEC, 0x8E, 0x16, 0xC8, 0xC7, 0xE1, 0x8C, 0xA0, 0x85, 0x5F, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF9, 0x3F, 0x98, 0x99, 0x5F, 0x97, 0xB6, 0x91, 0xEF, 0x5B, 0x2D, 0x2C, 0x1D, 0x11, 0x4D, + 0xE2, 0xDA, 0x5E, 0x75, 0x1F, 0xFF, 0xCC, 0x95, 0x35, 0x76, 0xB5, 0xA5, 0x7B, 0x3C, 0xD4, 0x3E, + 0x42, 0x51, 0x3D, 0xEF, 0x7D, 0xD2, 0x9B, 0xFB, 0x81, 0x34, 0x7C, 0x67, 0x79, 0xDD, 0x2E, 0x20, + 0x84, 0xA6, 0x8C, 0x71, 0xD8, 0xE7, 0xA6, 0x4C, 0xF1, 0x27, 0x31, 0xF1, 0x9A, 0x56, 0xF8, 0x6C, + 0x80, 0x2E, 0x01, 0x5F, 0xFF, 0xFD, 0x5F, 0x33, 0x2A, 0x49, 0x63, 0x05, 0xE8, 0x5E, 0x1D, 0x02, + 0x80, 0x8C, 0x4E, 0x9B, 0x06, 0x06, 0xCC, 0x46, 0x64, 0x33, 0x00, 0x51, 0x7C, 0x94, 0xA7, 0xCC, + 0x1A, 0x0C, 0x34, 0x71, 0x2C, 0xCC, 0x60, 0x31, 0xC1, 0xC9, 0xAE, 0x06, 0x44, 0x81, 0x43, 0x5F, + 0x5E, 0x0E, 0x60, 0x11, 0x95, 0x85, 0x4B, 0x6F, 0x3E, 0xE4, 0x20, 0x59, 0x96, 0x1E, 0x6B, 0x10, + 0x44, 0x92, 0x5D, 0x39, 0x59, 0x4B, 0xE9, 0x68, 0x65, 0x70, 0xF9, 0x76, 0x16, 0xF8, 0xEC, 0x27, + 0x5D, 0xF2, 0x21, 0xC6, 0x69, 0xE3, 0xDB, 0xEC, 0x9C, 0x42, 0xF4, 0xCF, 0x43, 0x8A, 0xC2, 0x4B, + 0x8F, 0x02, 0x40, 0x2A, 0xB1, 0xA7, 0xCA, 0xB7, 0x23, 0xDB, 0xFE, 0x9E, 0xB3, 0xD5, 0xA7, 0xE5, + 0x71, 0x98, 0x81, 0x63, 0x44, 0x34, 0xB9, 0x2B, 0xFF, 0xF4, 0xCD, 0x0B, 0xA0, 0xA3, 0x0C, 0xC5, + 0xCE, 0x4A, 0x4F, 0x12, 0x07, 0x04, 0x30, 0x96, 0x30, 0x13, 0x01, 0x61, 0x8D, 0xFF, 0xFF, 0xDA, + 0x35, 0xD1, 0xD2, 0x81, 0x88, 0xA3, 0xDE, 0x81, 0xD3, 0xD9, 0xAE, 0xDE, 0xDC, 0x3F, 0x28, 0x42, + 0x6A, 0x2D, 0xCC, 0xC4, 0xE7, 0x03, 0x81, 0x2E, 0x74, 0x36, 0x04, 0x74, 0x7D, 0x00, 0x95, 0xFF, + 0x3F, 0x84, 0xF4, 0x22, 0xBF, 0xFF, 0xFD, 0x5F, 0x3E, 0x42, 0x21, 0x01, 0xB8, 0x71, 0x6A, 0xA3, + 0x11, 0x0C, 0xCC, 0x33, 0x10, 0x30, 0x20, 0xA8, 0x28, 0x11, 0x36, 0x50, 0xF0, 0x42, 0x1F, 0x39, + 0x03, 0xE8, 0x10, 0x10, 0x1D, 0xB5, 0x09, 0x01, 0x44, 0x8B, 0x26, 0x70, 0x66, 0x99, 0x1C, 0x10, + 0x6F, 0x3A, 0x41, 0x44, 0x84, 0x46, 0x0F, 0x30, 0x20, 0x3D, 0x6A, 0x36, 0x14, 0x47, 0x49, 0x66, + 0x8F, 0x6A, 0x1D, 0x99, 0x6C, 0x0D, 0xD2, 0x43, 0x2C, 0xA5, 0x40, 0x0B, 0xBF, 0x2E, 0xF5, 0xF2, + 0x38, 0x22, 0x04, 0x40, 0xAA, 0xE0, 0xAC, 0x54, 0xFF, 0xFB, 0x92, 0x64, 0xEA, 0x0F, 0xF4, 0xFF, + 0x34, 0xCD, 0x03, 0xBA, 0x7B, 0xE0, 0x39, 0xE6, 0x98, 0xF0, 0x05, 0xEA, 0x7C, 0x0F, 0xD0, 0xD3, + 0x40, 0x0E, 0x61, 0x4D, 0xC0, 0xC8, 0x9A, 0x66, 0x80, 0x14, 0x89, 0xB8, 0xF2, 0xF1, 0x69, 0x6D, + 0x09, 0xB9, 0xB5, 0x48, 0x61, 0x11, 0x12, 0xE5, 0x46, 0x58, 0x60, 0x92, 0x41, 0xA8, 0x02, 0xC0, + 0xD9, 0x20, 0xFA, 0x19, 0xAA, 0x80, 0xA6, 0xE4, 0x36, 0xA7, 0xDE, 0x47, 0xF2, 0xF8, 0x8A, 0xDF, + 0x76, 0x8D, 0xA6, 0x02, 0x52, 0x87, 0x0F, 0x84, 0x65, 0x3F, 0xFF, 0xFF, 0xFF, 0xC5, 0x18, 0xE5, + 0x57, 0xAE, 0x97, 0xD1, 0xCF, 0xE8, 0xD4, 0xE5, 0xA5, 0x7B, 0xA6, 0x58, 0xA2, 0x9C, 0x63, 0xAA, + 0x66, 0xD8, 0x00, 0x03, 0x2C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x53, 0xBB, 0x57, 0xAF, 0x43, + 0x30, 0x40, 0xE5, 0x9C, 0x95, 0xFE, 0x94, 0xA6, 0x24, 0xBC, 0x30, 0xF9, 0xF2, 0x54, 0xC1, 0xCA, + 0xFF, 0xBE, 0xCB, 0xA5, 0x16, 0x53, 0xC8, 0x24, 0x28, 0xE0, 0x3B, 0xFF, 0xCC, 0xDB, 0x32, 0x17, + 0x13, 0xBE, 0x02, 0x0B, 0x0E, 0xC2, 0xFE, 0x30, 0xC2, 0x79, 0x94, 0x05, 0x46, 0xF8, 0x11, 0x98, + 0x90, 0x12, 0x70, 0x5A, 0xB9, 0x30, 0x8C, 0xAA, 0xD0, 0x05, 0x31, 0xCC, 0x36, 0x2C, 0x32, 0xED, + 0x98, 0x0C, 0xFF, 0x30, 0x71, 0x1C, 0x04, 0xDD, 0x42, 0x20, 0x20, 0x35, 0x08, 0x20, 0x40, 0x72, + 0x4D, 0xF3, 0x85, 0x52, 0x2E, 0xB7, 0xAD, 0x25, 0x4A, 0xF5, 0x8C, 0x2C, 0xD6, 0x75, 0x11, 0x49, + 0xB8, 0x0A, 0x16, 0xF8, 0x0E, 0x20, 0x7B, 0x1E, 0x5D, 0x92, 0xCE, 0xC5, 0xD5, 0x2C, 0x34, 0x81, + 0x14, 0xD3, 0xA8, 0x60, 0x88, 0x6D, 0x06, 0x8E, 0x21, 0x41, 0x50, 0x81, 0x60, 0x42, 0x01, 0x46, + 0xC3, 0x94, 0x03, 0x58, 0x14, 0x06, 0xA8, 0xB2, 0xD4, 0x68, 0xEF, 0x27, 0x77, 0x28, 0x8D, 0xB3, + 0x96, 0x15, 0x52, 0xA8, 0xC1, 0x57, 0x23, 0x69, 0xFF, 0xFF, 0xDF, 0x5F, 0xE1, 0x16, 0xAF, 0x80, + 0xAD, 0x52, 0x27, 0x8B, 0x7B, 0x4F, 0x7D, 0x69, 0x10, 0x19, 0x27, 0xC2, 0xE8, 0x37, 0x8B, 0x64, + 0x5D, 0x0C, 0x05, 0x7C, 0x80, 0x27, 0x59, 0xF9, 0x62, 0x16, 0xA7, 0xBC, 0xC3, 0x12, 0x27, 0x92, + 0x30, 0x6A, 0x7E, 0x24, 0x4E, 0xC3, 0x7D, 0x80, 0xD4, 0x49, 0x0B, 0x08, 0x37, 0x44, 0x04, 0x10, + 0x04, 0x1D, 0x6A, 0x7F, 0x51, 0x64, 0x12, 0xFF, 0xD4, 0x7C, 0x36, 0x0A, 0xC0, 0xAD, 0x26, 0x80, + 0x6A, 0x59, 0x60, 0x40, 0x14, 0xD1, 0x2B, 0x78, 0xC4, 0xF1, 0x5C, 0x1B, 0x58, 0x76, 0x05, 0x66, + 0x5C, 0xC2, 0x7A, 0x5E, 0xC6, 0x8E, 0x3E, 0x16, 0x2B, 0x31, 0x53, 0x61, 0x00, 0xF1, 0x82, 0x32, + 0x1C, 0xB8, 0x70, 0x8C, 0x78, 0xE2, 0x15, 0x00, 0x42, 0xCC, 0x91, 0x1A, 0xB0, 0x5A, 0x71, 0x5C, + 0x38, 0x43, 0x31, 0x64, 0x90, 0x68, 0x58, 0x76, 0xBA, 0xCF, 0x12, 0x8A, 0x99, 0x00, 0xA9, 0x84, + 0xEF, 0x2D, 0x00, 0x00, 0x23, 0xB0, 0x3A, 0x69, 0xCC, 0x48, 0xFF, 0xFB, 0x92, 0x64, 0xE3, 0x8F, + 0x34, 0x75, 0x35, 0x4F, 0x03, 0x98, 0x7D, 0xA0, 0x30, 0x23, 0xCA, 0x0E, 0x08, 0x66, 0x68, 0x11, + 0xEC, 0xD3, 0x3A, 0x0E, 0x65, 0xEF, 0x80, 0xBE, 0x91, 0xA7, 0xD0, 0x60, 0x8C, 0xF0, 0x13, 0x53, + 0x07, 0x0A, 0x56, 0x12, 0xAA, 0x96, 0x85, 0x81, 0x8A, 0x94, 0x90, 0xAB, 0x59, 0x2F, 0x1D, 0xC5, + 0x45, 0x1D, 0x6B, 0x61, 0x45, 0x45, 0xB8, 0x46, 0xE5, 0x56, 0x90, 0xAE, 0x56, 0xA3, 0xAC, 0x22, + 0x49, 0xCC, 0x11, 0x13, 0xAC, 0xA1, 0x0E, 0x4A, 0x7C, 0xAE, 0x07, 0xFA, 0x8A, 0xA7, 0x3F, 0xF3, + 0xDC, 0x96, 0xF4, 0xDC, 0x72, 0x4C, 0xC8, 0x12, 0x21, 0x4C, 0x9C, 0x95, 0x05, 0x6C, 0x6F, 0xFC, + 0x9F, 0x9F, 0xDA, 0x7B, 0x2D, 0xD6, 0xC3, 0xCA, 0xAC, 0x09, 0xA1, 0x3B, 0x99, 0x80, 0x36, 0x00, + 0x03, 0xCB, 0xD5, 0xA3, 0x0C, 0x3F, 0x7F, 0xB2, 0xE6, 0xED, 0xFF, 0xA5, 0xFD, 0x7C, 0xF3, 0xBA, + 0xDC, 0x11, 0x90, 0x51, 0x2D, 0x90, 0x03, 0x0E, 0x22, 0x90, 0xD1, 0x23, 0x2B, 0x10, 0xBA, 0xF5, + 0x0A, 0x36, 0x30, 0x55, 0xFE, 0x9D, 0xFA, 0x8E, 0x45, 0xA9, 0x40, 0xC0, 0xD1, 0xB5, 0x3D, 0xB9, + 0x81, 0x80, 0xE1, 0x98, 0xC8, 0x20, 0x6F, 0x29, 0x88, 0x88, 0x47, 0x2C, 0x56, 0x98, 0xD5, 0x4C, + 0x62, 0xC0, 0x49, 0x99, 0x46, 0x86, 0x48, 0x1A, 0x9F, 0x6D, 0x28, 0x44, 0xEB, 0x30, 0x38, 0x80, + 0xFE, 0x65, 0x87, 0x1E, 0x52, 0x7C, 0xCA, 0x94, 0x61, 0xDE, 0x54, 0x3D, 0x5E, 0x2C, 0xD5, 0xD5, + 0x47, 0x27, 0x1A, 0xCB, 0x3B, 0x99, 0x60, 0x0B, 0x56, 0x5C, 0xFB, 0x3A, 0x6B, 0xAD, 0x30, 0x57, + 0xCA, 0x22, 0x55, 0x5E, 0x32, 0x37, 0x61, 0x9B, 0x21, 0xD9, 0x56, 0x97, 0xB9, 0xC3, 0x71, 0x99, + 0xBA, 0xEB, 0xB2, 0xBC, 0x10, 0x55, 0x7A, 0xFA, 0x83, 0x93, 0x11, 0x79, 0x35, 0x0B, 0x1A, 0xA9, + 0x00, 0x48, 0x63, 0xC8, 0x4A, 0x22, 0x5A, 0xAB, 0xB1, 0xDB, 0x71, 0xFA, 0x78, 0xC3, 0xE9, 0x1D, + 0xE5, 0xD8, 0xC4, 0x1B, 0x4A, 0xF5, 0x48, 0xD2, 0xAC, 0x20, 0xE8, 0xF2, 0xCB, 0x0B, 0xCA, 0xCB, + 0x12, 0x9A, 0x47, 0x9F, 0xEC, 0xBC, 0xF2, 0xF6, 0x30, 0xF3, 0x2B, 0xE5, 0xD0, 0xDB, 0xC5, 0xEA, + 0x70, 0xC2, 0xC1, 0x10, 0x0D, 0x19, 0xAA, 0x0A, 0x63, 0x3D, 0x94, 0x2C, 0x36, 0x31, 0xD4, 0xAE, + 0x73, 0x57, 0xA3, 0x59, 0x6B, 0xD5, 0x04, 0x95, 0xB6, 0x3A, 0x89, 0x43, 0x86, 0x8D, 0x0D, 0xFB, + 0x08, 0x06, 0x14, 0xE1, 0xCF, 0x55, 0x94, 0x00, 0x2F, 0x29, 0x37, 0xB1, 0xEA, 0x30, 0x03, 0x01, + 0x63, 0x06, 0x51, 0x25, 0x31, 0x76, 0x5B, 0x63, 0x02, 0x00, 0xDA, 0x33, 0x4E, 0xA4, 0xD4, 0x8B, + 0x33, 0x1E, 0x92, 0x0F, 0x46, 0xD4, 0x31, 0xB1, 0x6C, 0xC4, 0x04, 0xC3, 0x56, 0x97, 0x0C, 0x8A, + 0x1D, 0x32, 0x7F, 0x8D, 0xC9, 0x03, 0x22, 0x60, 0xD8, 0x83, 0x21, 0x26, 0x64, 0x43, 0x5C, 0x5E, + 0x12, 0x98, 0xD3, 0x37, 0x91, 0x32, 0x66, 0xBE, 0xED, 0x31, 0xC2, 0x50, 0xFF, 0xFB, 0x90, 0x64, + 0xE3, 0x8F, 0x14, 0xBD, 0x34, 0xCD, 0x03, 0xBB, 0xC8, 0xC0, 0x2C, 0xA4, 0x69, 0xD4, 0x24, 0x65, + 0x6C, 0x12, 0xF0, 0xD5, 0x30, 0x0E, 0xF3, 0x03, 0x00, 0xB1, 0x12, 0xE8, 0x24, 0x50, 0x9B, 0x0A, + 0x05, 0xE9, 0x41, 0x98, 0xF2, 0x65, 0x2A, 0x44, 0xF8, 0xA0, 0x51, 0x01, 0x18, 0xB4, 0x64, 0x66, + 0xEC, 0xA1, 0x52, 0x49, 0x58, 0x0D, 0x22, 0x22, 0xA5, 0x32, 0xB1, 0xB5, 0xE1, 0xE0, 0xEF, 0x02, + 0x87, 0x28, 0xCC, 0x06, 0xC5, 0x60, 0x35, 0x6C, 0x53, 0x56, 0xE6, 0x82, 0x46, 0x0E, 0xC1, 0xE4, + 0x94, 0x14, 0xC8, 0xF0, 0xDA, 0x40, 0x2C, 0x78, 0xC8, 0x80, 0x2F, 0xFB, 0x9B, 0x4C, 0xA3, 0xAB, + 0x08, 0xC6, 0xA4, 0xEE, 0x0D, 0x16, 0xB2, 0x80, 0x17, 0xB4, 0xD2, 0x93, 0x48, 0x74, 0x11, 0xAE, + 0x24, 0x28, 0x47, 0xA4, 0x43, 0x68, 0x16, 0xA1, 0x8A, 0x46, 0x96, 0xCE, 0x9C, 0x67, 0x6D, 0x7B, + 0xA9, 0x35, 0x84, 0x66, 0x52, 0xCB, 0xC1, 0x81, 0x50, 0x00, 0x09, 0x6A, 0x81, 0x87, 0xA6, 0x80, + 0xA4, 0xB3, 0x0C, 0xE8, 0x69, 0xB1, 0x29, 0x7C, 0x33, 0xFF, 0x53, 0xA4, 0x6A, 0xD7, 0xCA, 0x99, + 0xA7, 0x1D, 0xD4, 0xB0, 0x1A, 0xA5, 0xFB, 0x4A, 0x48, 0xB3, 0xB4, 0x99, 0xFF, 0xF2, 0xD4, 0xD0, + 0xA3, 0x89, 0x7F, 0xD3, 0x64, 0x01, 0x61, 0x60, 0x31, 0x30, 0x24, 0x10, 0x03, 0x40, 0x66, 0x4D, + 0x31, 0x25, 0x06, 0xE3, 0x04, 0x82, 0x17, 0x30, 0xFD, 0x07, 0x93, 0x0B, 0xA1, 0x4B, 0x25, 0x02, + 0x63, 0xB1, 0xA1, 0x38, 0x8A, 0xA0, 0xCF, 0xA3, 0x18, 0x7F, 0x33, 0xA2, 0x53, 0x06, 0x4A, 0x0C, + 0x7A, 0x0E, 0x01, 0x65, 0x41, 0xA5, 0x7D, 0xEC, 0x46, 0x9B, 0x83, 0x12, 0x78, 0xD3, 0xF9, 0xB3, + 0xAF, 0x17, 0xD4, 0x86, 0x08, 0x88, 0x93, 0x89, 0x30, 0x54, 0x01, 0x77, 0xD6, 0xC8, 0xA8, 0xDA, + 0xE2, 0x00, 0xCB, 0x21, 0x48, 0xC2, 0x99, 0x8C, 0xEC, 0xB6, 0x9D, 0xF6, 0x61, 0xCC, 0xBD, 0x86, + 0xAF, 0x87, 0x45, 0x8E, 0xAD, 0x77, 0xF9, 0xDA, 0x80, 0x92, 0xAD, 0x3F, 0xCB, 0x4C, 0x67, 0x31, + 0x5C, 0xD0, 0x61, 0x51, 0xD0, 0x0E, 0x35, 0x4F, 0xAA, 0x18, 0xFB, 0x90, 0xA3, 0xAD, 0x06, 0x1F, + 0x4A, 0xF4, 0xE1, 0x62, 0xF7, 0xA3, 0x2A, 0xCB, 0x3B, 0x28, 0xA4, 0x6C, 0x2D, 0xF5, 0x22, 0x62, + 0x2F, 0xC0, 0x21, 0xA1, 0xC5, 0xEC, 0xE5, 0xB3, 0xB2, 0xCA, 0x35, 0x06, 0x18, 0xB0, 0x88, 0x05, + 0x56, 0x86, 0xB2, 0x94, 0xAC, 0xBD, 0x3C, 0x17, 0x3B, 0xD1, 0x0D, 0x98, 0xDF, 0x27, 0xF8, 0x6A, + 0x93, 0x0C, 0x5E, 0xAB, 0xA7, 0x83, 0x47, 0xFB, 0x20, 0x7A, 0xAB, 0x18, 0xAA, 0xE8, 0xCF, 0xAA, + 0x76, 0x28, 0xC2, 0x10, 0x42, 0xE0, 0x3A, 0xBB, 0xDD, 0x37, 0x8C, 0xFD, 0xA9, 0x46, 0x1C, 0xD0, + 0xEE, 0xD1, 0xF3, 0xAF, 0x71, 0x19, 0xB4, 0xED, 0x7B, 0x40, 0xB3, 0x8A, 0xAF, 0x30, 0x10, 0x00, + 0xE3, 0x09, 0x51, 0x8F, 0x37, 0x9B, 0x4B, 0x23, 0x07, 0xF1, 0x3F, 0x32, 0x90, 0xFF, 0xFB, 0x92, + 0x64, 0xDE, 0x0F, 0x75, 0x2B, 0x34, 0xCA, 0x83, 0xDC, 0xD0, 0xB0, 0x30, 0x05, 0xB9, 0xA4, 0x08, + 0xC3, 0x50, 0x54, 0x98, 0xD1, 0x28, 0x0F, 0x6F, 0x06, 0x80, 0xC7, 0x17, 0x25, 0x94, 0x11, 0x99, + 0x29, 0xC3, 0x36, 0x8C, 0x1E, 0x30, 0xE8, 0x7F, 0x38, 0xF8, 0x58, 0x35, 0x88, 0x10, 0x32, 0xB8, + 0x7E, 0x36, 0xC4, 0x06, 0x69, 0x83, 0xC0, 0x89, 0x3E, 0x38, 0x2E, 0xD5, 0x0A, 0x33, 0x1B, 0x90, + 0xF2, 0x19, 0x33, 0x96, 0xC0, 0xD0, 0x31, 0xE4, 0x7B, 0x18, 0x3B, 0x1A, 0x75, 0x95, 0x58, 0x1C, + 0x3D, 0x22, 0x4B, 0x88, 0x48, 0x01, 0x6A, 0xBB, 0x0E, 0xBA, 0x8B, 0x27, 0xBA, 0x4E, 0xCF, 0x3A, + 0x0F, 0xBF, 0x72, 0xEF, 0xED, 0xBA, 0xB8, 0xC9, 0x22, 0x59, 0x64, 0xAF, 0x58, 0x74, 0xE8, 0x49, + 0x96, 0x22, 0xC0, 0x64, 0xE8, 0xF3, 0x24, 0x72, 0xCB, 0x93, 0x23, 0xAC, 0xAA, 0xEC, 0xEA, 0x17, + 0x29, 0x96, 0x3A, 0xAB, 0xE2, 0x00, 0x46, 0xE5, 0x9E, 0x9B, 0x05, 0xAE, 0xA2, 0x56, 0x59, 0xD7, + 0x4E, 0xF3, 0xA7, 0x49, 0x2A, 0x68, 0x44, 0x42, 0x4B, 0x4C, 0x04, 0x0A, 0xC2, 0x52, 0x49, 0xA8, + 0x38, 0xE1, 0x60, 0x6E, 0x50, 0x70, 0x25, 0x81, 0xB0, 0xC5, 0xDB, 0xB3, 0x8D, 0x05, 0xC3, 0xD0, + 0xD3, 0x2C, 0xCC, 0x18, 0xAB, 0x20, 0x00, 0x33, 0x83, 0x43, 0xA4, 0x3E, 0xD4, 0x67, 0x2F, 0x43, + 0x2C, 0xB2, 0x63, 0x03, 0xDD, 0x90, 0x4D, 0xEF, 0x9F, 0xFF, 0xF5, 0x03, 0x0B, 0xA9, 0x12, 0x33, + 0xD6, 0x7F, 0x1F, 0x6C, 0x6E, 0x5D, 0x63, 0x54, 0x8F, 0x1F, 0x06, 0x13, 0x6D, 0xEC, 0xB0, 0x60, + 0x02, 0x03, 0x46, 0x19, 0xC0, 0xC2, 0x74, 0x70, 0x89, 0x26, 0x15, 0x40, 0xD4, 0x62, 0x6A, 0x21, + 0xE6, 0x77, 0xE1, 0x72, 0x60, 0x78, 0x10, 0x66, 0x3A, 0x63, 0xAE, 0x63, 0x40, 0x27, 0xE4, 0x3E, + 0x4F, 0x0E, 0x64, 0x44, 0x66, 0x95, 0x2E, 0x62, 0x62, 0x42, 0x4E, 0x63, 0x40, 0xE5, 0xE4, 0x32, + 0x24, 0x06, 0xE7, 0x11, 0x72, 0xC7, 0x06, 0xA0, 0x33, 0xB1, 0x24, 0x0E, 0xB4, 0xA2, 0xA8, 0x1C, + 0x80, 0xA0, 0x14, 0x8B, 0xD8, 0x15, 0x08, 0x91, 0x41, 0x09, 0x04, 0x19, 0x54, 0x51, 0xC5, 0x2F, + 0x97, 0xDA, 0x11, 0x37, 0x78, 0x3E, 0xA7, 0x3F, 0xEC, 0x97, 0x19, 0x4E, 0x51, 0x1B, 0x6B, 0x59, + 0xA4, 0x20, 0x09, 0xF4, 0x5A, 0xAA, 0xDB, 0x2E, 0x75, 0xD3, 0xAD, 0xBF, 0x49, 0xE8, 0xBA, 0xFA, + 0x87, 0x5F, 0xEE, 0x6A, 0x34, 0xF1, 0xBE, 0x8E, 0x05, 0xEA, 0xF6, 0xA2, 0xAE, 0x8A, 0xE1, 0x75, + 0x50, 0x8D, 0xAC, 0xA8, 0x04, 0xEC, 0xF0, 0x54, 0x2D, 0x3A, 0x6D, 0x0A, 0xD5, 0xE2, 0x1A, 0xA3, + 0xD2, 0xF4, 0x1A, 0xBB, 0x30, 0xA9, 0xB9, 0xC5, 0xE8, 0xDA, 0x17, 0xED, 0x97, 0x30, 0xF4, 0xE1, + 0xC1, 0xC0, 0x00, 0x01, 0x00, 0xB4, 0x1C, 0x08, 0x9A, 0x76, 0x08, 0xD4, 0x09, 0xD4, 0x6A, 0x68, + 0x47, 0x6D, 0xCA, 0x5D, 0xCA, 0x28, 0x85, 0xF1, 0x35, 0x98, 0x39, 0xBF, 0xBD, 0x41, 0xA5, 0xFF, + 0xFB, 0x92, 0x64, 0xC7, 0x0F, 0x35, 0x0E, 0x34, 0xCA, 0x83, 0xDD, 0xD0, 0xA0, 0x2C, 0x22, 0x49, + 0xA4, 0x08, 0x23, 0x0A, 0x54, 0x3C, 0xD3, 0x28, 0x0F, 0x6F, 0x06, 0xC0, 0xBC, 0x07, 0xA6, 0xD0, + 0xF3, 0x08, 0x59, 0xF8, 0x72, 0x63, 0x3D, 0xFC, 0x3F, 0xFD, 0x7F, 0x2F, 0x31, 0x0D, 0x53, 0xEA, + 0x5A, 0x6D, 0x9A, 0x29, 0x30, 0x04, 0x02, 0x63, 0x0A, 0x51, 0x5C, 0x3A, 0x0F, 0x46, 0x43, 0x10, + 0xA0, 0xF8, 0x11, 0xDF, 0xA7, 0xE6, 0x87, 0x06, 0x1C, 0x9F, 0x26, 0xDF, 0x06, 0x07, 0x02, 0x9D, + 0x06, 0x51, 0x07, 0xE7, 0x02, 0x9D, 0x66, 0x09, 0x86, 0x44, 0xA5, 0x80, 0x34, 0x0B, 0x0C, 0x04, + 0x41, 0xC9, 0x92, 0xAC, 0x3C, 0xD8, 0x71, 0x55, 0xD1, 0x06, 0x3A, 0x8E, 0x12, 0xE8, 0x01, 0x12, + 0x21, 0x12, 0xC0, 0xC2, 0xA3, 0xA3, 0xF0, 0x16, 0xCD, 0xC8, 0x36, 0x0C, 0x44, 0xC0, 0x30, 0x6E, + 0x02, 0x13, 0x14, 0x18, 0x58, 0xF5, 0x9B, 0x1D, 0x7B, 0xA3, 0x52, 0x0E, 0xD6, 0x5E, 0x66, 0xAA, + 0x26, 0x48, 0x4A, 0x22, 0xC7, 0x13, 0xE0, 0x90, 0x26, 0xE4, 0x5A, 0xE2, 0xE2, 0xA4, 0x63, 0x38, + 0x1E, 0x26, 0x38, 0x9C, 0x45, 0x64, 0x38, 0xEF, 0x63, 0xE4, 0xEE, 0xE3, 0xB9, 0x87, 0xF7, 0x08, + 0x94, 0x35, 0x3D, 0x29, 0xFA, 0x8F, 0xBB, 0x5A, 0x9E, 0x61, 0x0C, 0xEE, 0x5A, 0xDC, 0x10, 0x14, + 0xDF, 0x2B, 0x2A, 0x6B, 0x4B, 0x26, 0xD2, 0xFD, 0xE7, 0x0C, 0x69, 0x46, 0x9C, 0xDA, 0xB1, 0x36, + 0xB6, 0x91, 0xE9, 0x8A, 0x89, 0xC9, 0xD7, 0x01, 0x9E, 0xFF, 0xFA, 0x47, 0xA0, 0x00, 0x01, 0x00, + 0x00, 0x00, 0xA0, 0x75, 0x4E, 0x86, 0xC7, 0xA6, 0xB0, 0x0E, 0x0C, 0x48, 0x7C, 0x99, 0x43, 0xDD, + 0x76, 0xF1, 0x61, 0xCE, 0x0C, 0xB6, 0x20, 0x20, 0xB2, 0x60, 0x27, 0xEE, 0x40, 0x85, 0xE0, 0x3B, + 0xD1, 0x3F, 0xC8, 0x57, 0x3A, 0xA7, 0x15, 0xB4, 0xD3, 0x19, 0xA3, 0xFF, 0xFE, 0xA0, 0x08, 0x2E, + 0x18, 0x17, 0x05, 0xE9, 0xC4, 0x52, 0x5D, 0x98, 0x54, 0x85, 0x41, 0x85, 0xE1, 0xF6, 0x99, 0x1F, + 0x87, 0x61, 0x00, 0x2F, 0x18, 0x9A, 0xA2, 0xC1, 0xC0, 0x06, 0x61, 0x9A, 0x2D, 0xE9, 0xCC, 0xA4, + 0x81, 0x81, 0xA1, 0x29, 0x9C, 0x08, 0xF1, 0x28, 0xE6, 0x64, 0x08, 0x18, 0x07, 0x2C, 0xB0, 0x85, + 0x5B, 0xBB, 0x69, 0x81, 0x51, 0x57, 0x09, 0x50, 0x32, 0xF7, 0x4C, 0xCB, 0x89, 0x94, 0xA2, 0x19, + 0xA9, 0x02, 0x9B, 0xC6, 0x4E, 0xB0, 0xF1, 0xD1, 0x01, 0x43, 0xE8, 0x69, 0x55, 0xCC, 0xB1, 0x04, + 0x48, 0x45, 0x40, 0xCF, 0xA3, 0xC6, 0x4B, 0xDC, 0xE2, 0x38, 0x08, 0xE1, 0x21, 0x9A, 0x9D, 0x2F, + 0xBA, 0xC2, 0x18, 0x85, 0xC3, 0x4A, 0x49, 0x9E, 0x0B, 0x1C, 0x00, 0x81, 0x41, 0x46, 0x9A, 0xD6, + 0x1A, 0x5A, 0xF6, 0x52, 0xF1, 0x80, 0x0B, 0x69, 0xAA, 0xEA, 0x6A, 0x0E, 0xCB, 0xBF, 0x04, 0x51, + 0xE5, 0x8E, 0xF5, 0xFF, 0x5A, 0xD5, 0x58, 0x79, 0x8D, 0x26, 0xA4, 0xE3, 0xEF, 0x06, 0xAE, 0x55, + 0x0D, 0xFF, 0xFB, 0x92, 0x64, 0xB6, 0x8F, 0x15, 0x3A, 0x34, 0x49, 0x83, 0xDD, 0xC8, 0xC0, 0x32, + 0x41, 0x29, 0xDD, 0x64, 0x29, 0x10, 0x15, 0x94, 0xD7, 0x26, 0x0F, 0x77, 0x46, 0x80, 0xA7, 0x0C, + 0xA7, 0x8C, 0xC4, 0x8C, 0x20, 0x59, 0xB7, 0xD3, 0x31, 0xAF, 0x96, 0xFD, 0xCF, 0x51, 0xC8, 0xAC, + 0xB1, 0x86, 0x21, 0x1B, 0x8A, 0x2C, 0x19, 0xCD, 0x31, 0xA0, 0xD6, 0x34, 0xE5, 0xBE, 0x00, 0x05, + 0x4C, 0x13, 0x04, 0xBF, 0xB4, 0x28, 0x55, 0x0F, 0x8A, 0x52, 0x1F, 0x50, 0x38, 0x49, 0xF3, 0xB5, + 0x32, 0x1E, 0x32, 0xEC, 0xE2, 0x04, 0x13, 0x96, 0x5E, 0x7C, 0xA8, 0x3A, 0x5C, 0xDD, 0xEF, 0xD4, + 0x7E, 0x77, 0x16, 0xB0, 0x7B, 0xD4, 0x47, 0xD2, 0x30, 0x10, 0x09, 0x31, 0x54, 0x96, 0x3E, 0xA7, + 0xD0, 0x30, 0xD4, 0x75, 0x30, 0xF2, 0x5B, 0x3A, 0x80, 0xF0, 0x31, 0x40, 0x91, 0x38, 0xB6, 0x15, + 0x35, 0x58, 0x75, 0x31, 0x7C, 0x01, 0x36, 0x18, 0xA0, 0x30, 0xA0, 0x0F, 0x38, 0x79, 0xC3, 0x66, + 0x13, 0x36, 0x65, 0x03, 0x28, 0x04, 0x81, 0xC5, 0x54, 0xC4, 0x82, 0x9A, 0x08, 0x88, 0x0D, 0xAC, + 0x32, 0xA1, 0xE0, 0x76, 0xBE, 0x44, 0x2B, 0x4E, 0xB0, 0x60, 0xA2, 0x06, 0x92, 0x60, 0xA3, 0x23, + 0xCB, 0x29, 0x28, 0x68, 0x25, 0x6C, 0x50, 0xB0, 0x6C, 0x2C, 0x70, 0xE6, 0x18, 0x48, 0xEA, 0x9C, + 0xB0, 0x98, 0x72, 0x09, 0x4C, 0xBB, 0x3F, 0xB0, 0xB0, 0x61, 0x85, 0x42, 0x18, 0x71, 0x38, 0x38, + 0x6C, 0xC5, 0x42, 0x02, 0x05, 0x0B, 0x92, 0x1C, 0x13, 0x68, 0xBD, 0x0C, 0x5D, 0x98, 0xA7, 0x33, + 0x76, 0x7D, 0xA7, 0x39, 0x5A, 0xCF, 0xFF, 0xCD, 0x4F, 0xFF, 0xFF, 0xFF, 0xFF, 0xE5, 0xD8, 0x31, + 0xA7, 0xF1, 0xA2, 0xA2, 0xDB, 0x61, 0x0E, 0x22, 0xF7, 0x41, 0x20, 0x5C, 0x0E, 0xE8, 0x28, 0x2A, + 0x4D, 0xA3, 0x3C, 0xF5, 0x29, 0x94, 0x45, 0xE2, 0x40, 0x72, 0x6A, 0xA8, 0x09, 0xDC, 0xB8, 0x04, + 0x80, 0x00, 0x10, 0x03, 0x8A, 0x21, 0x95, 0xBC, 0x26, 0x17, 0x90, 0x1C, 0x03, 0x8D, 0xC9, 0xBF, + 0xC6, 0xE6, 0x2B, 0x34, 0xFD, 0x55, 0x8F, 0x1D, 0x9F, 0x71, 0x7D, 0xFF, 0x83, 0x70, 0xB9, 0x62, + 0xEE, 0x43, 0x49, 0x68, 0xFF, 0xD5, 0x48, 0x50, 0x58, 0xA3, 0x96, 0xD9, 0x45, 0x10, 0x08, 0x5C, + 0x02, 0x30, 0x60, 0x63, 0x33, 0x71, 0xD3, 0x0B, 0x17, 0x26, 0x05, 0x80, 0x26, 0xCA, 0x02, 0x60, + 0x00, 0xC4, 0xC2, 0xC8, 0x64, 0x14, 0xE9, 0x02, 0x87, 0x13, 0x1B, 0xCC, 0x10, 0x50, 0x22, 0x62, + 0x85, 0x84, 0x71, 0x7D, 0x42, 0x84, 0x61, 0x62, 0x00, 0x26, 0x4C, 0x0E, 0x0D, 0x21, 0x97, 0xD0, + 0xAB, 0x74, 0xB1, 0x65, 0x27, 0xBC, 0x08, 0x54, 0x06, 0x96, 0x48, 0x4D, 0x32, 0x43, 0x0A, 0x04, + 0x4C, 0x84, 0x17, 0x40, 0x51, 0x8E, 0x1A, 0xB3, 0xD9, 0xD3, 0x24, 0xAD, 0x6D, 0xAF, 0x4C, 0x5B, + 0xDE, 0x23, 0xA1, 0x0C, 0xB9, 0x43, 0x5B, 0x1C, 0x5A, 0x5A, 0x00, 0x51, 0x31, 0xBD, 0x59, 0x8A, + 0xF5, 0x1B, 0x33, 0xFF, 0xFB, 0x92, 0x64, 0x9D, 0x8D, 0x75, 0x39, 0x34, 0xCB, 0x03, 0xBB, 0xC2, + 0xF0, 0x2E, 0xE3, 0x99, 0xB8, 0x19, 0x48, 0x16, 0x11, 0xA0, 0xD5, 0x36, 0x2E, 0xE9, 0xEB, 0xD0, + 0xC4, 0x15, 0xE6, 0xE0, 0xD4, 0x8A, 0x21, 0x12, 0x12, 0xA7, 0x40, 0x38, 0x6E, 0xFF, 0xFF, 0x6D, + 0xFC, 0xFF, 0xFF, 0xFE, 0x8D, 0xF8, 0xBB, 0xC6, 0x06, 0x13, 0x19, 0x89, 0x0E, 0x23, 0x29, 0x81, + 0xF8, 0x7D, 0xC2, 0x8D, 0xCC, 0x07, 0x23, 0xF0, 0x35, 0x28, 0xD1, 0x3B, 0x21, 0xEB, 0x7A, 0x03, + 0x18, 0x1B, 0x8D, 0x7D, 0x4E, 0x93, 0xD4, 0x25, 0xA7, 0x8B, 0x2B, 0x4B, 0xC9, 0x26, 0xA5, 0x9E, + 0xB3, 0xA4, 0x80, 0x8F, 0x57, 0x6F, 0xC7, 0xF8, 0x7F, 0xFD, 0x0A, 0xC5, 0x28, 0xCF, 0x09, 0xAE, + 0x05, 0x8A, 0xE5, 0xFA, 0x9F, 0xFF, 0xFA, 0x17, 0x86, 0x8A, 0x74, 0x7B, 0x7C, 0xE5, 0xC0, 0xB3, + 0x2D, 0x49, 0xDE, 0xC9, 0xAA, 0x8C, 0xC1, 0x8E, 0x27, 0x91, 0x8C, 0xA6, 0x31, 0xC3, 0x29, 0x49, + 0x8B, 0x60, 0xB9, 0x8D, 0xD3, 0x79, 0xCB, 0x20, 0x41, 0x85, 0x64, 0x99, 0xA1, 0x40, 0x98, 0xD3, + 0x14, 0x1D, 0xC4, 0x23, 0x81, 0xC2, 0x4A, 0x6B, 0x09, 0xAD, 0xF8, 0xE9, 0x81, 0x28, 0xDA, 0xB2, + 0xA1, 0xA0, 0xCD, 0x2C, 0x50, 0x3A, 0x90, 0x52, 0xB0, 0xA0, 0x67, 0xF0, 0x42, 0x4D, 0x06, 0x9A, + 0x31, 0xA1, 0x14, 0x3D, 0x42, 0x28, 0x23, 0x31, 0x42, 0x42, 0x48, 0xCF, 0x81, 0x6F, 0x88, 0x84, + 0x2E, 0x08, 0xCA, 0x82, 0x39, 0x9D, 0xC2, 0xD2, 0x0C, 0x34, 0xA2, 0x53, 0xA0, 0xC8, 0x45, 0x06, + 0x04, 0x61, 0x45, 0x96, 0x2C, 0xC4, 0x39, 0xA9, 0x55, 0xBA, 0x89, 0xF4, 0xEC, 0xBA, 0x96, 0xAE, + 0xDF, 0x86, 0x3B, 0xFF, 0xFF, 0xFA, 0xE7, 0xE7, 0xAF, 0xFD, 0x71, 0xAA, 0xC3, 0xD8, 0xB1, 0x88, + 0x06, 0xC2, 0x29, 0x4B, 0x52, 0x79, 0xDA, 0x67, 0x63, 0x00, 0xDF, 0xAD, 0xFF, 0x21, 0xA7, 0x95, + 0xB9, 0x44, 0xDF, 0x88, 0x93, 0x0A, 0x95, 0x74, 0x20, 0x80, 0x01, 0x81, 0x49, 0x5E, 0xE7, 0xFF, + 0xFE, 0xF6, 0x0A, 0x12, 0x8F, 0x6D, 0xC6, 0x69, 0x82, 0xF3, 0xFE, 0x02, 0xC3, 0x80, 0x54, 0xB3, + 0x49, 0x7A, 0xDE, 0x9C, 0x47, 0xF5, 0x6A, 0x24, 0x92, 0x3C, 0xE2, 0x3E, 0x40, 0x53, 0x27, 0xFF, + 0xD6, 0x48, 0x0B, 0x1A, 0x52, 0x20, 0x2E, 0x77, 0xA7, 0x45, 0x8E, 0xAA, 0x66, 0x20, 0x2D, 0x9F, + 0x26, 0x98, 0x68, 0xC2, 0xF1, 0x22, 0xAC, 0xFB, 0xB6, 0xA3, 0x01, 0x81, 0x8C, 0x91, 0xD7, 0x3C, + 0xEC, 0x5F, 0x32, 0x68, 0x4B, 0x32, 0x41, 0xAE, 0x31, 0x8C, 0x30, 0x04, 0x08, 0x3E, 0xB0, 0xCD, + 0xA9, 0xB3, 0x10, 0x44, 0x58, 0xF2, 0x16, 0xAB, 0xA5, 0x23, 0x06, 0xA9, 0x08, 0xAB, 0x3F, 0x44, + 0x56, 0x62, 0xE3, 0x3E, 0x62, 0x81, 0x40, 0xCD, 0x54, 0x34, 0xC3, 0x0D, 0x1B, 0x02, 0xC3, 0x53, + 0x8C, 0xAC, 0x22, 0xA6, 0x11, 0x08, 0x86, 0x1D, 0x26, 0x3B, 0x28, 0x71, 0x98, 0xA6, 0x7F, 0x2A, + 0x20, 0x2C, 0x0E, 0x05, 0x23, 0xFF, 0xFB, 0x92, 0x64, 0x92, 0x8F, 0x54, 0xBE, 0x35, 0x4C, 0x03, + 0x3D, 0xD0, 0x40, 0x33, 0x26, 0x99, 0x88, 0x18, 0x23, 0xD4, 0x12, 0x88, 0xD5, 0x30, 0x0E, 0x77, + 0x46, 0x40, 0xB8, 0x98, 0xE5, 0xE0, 0x24, 0x09, 0x79, 0x10, 0x5B, 0x0E, 0x32, 0xE3, 0xA7, 0xEC, + 0xB4, 0x64, 0x19, 0x12, 0xCC, 0xEF, 0x43, 0xB9, 0x44, 0x5C, 0xC9, 0x14, 0xFC, 0xFE, 0x1F, 0xFF, + 0xFF, 0x72, 0xDD, 0x7A, 0x1A, 0xF5, 0xFB, 0xBC, 0x6E, 0xC1, 0x36, 0x22, 0x4D, 0x9E, 0x99, 0xDF, + 0x81, 0x60, 0x27, 0xE5, 0xBC, 0xE5, 0xBC, 0x77, 0x4F, 0x28, 0x86, 0xBB, 0x2D, 0x49, 0x15, 0xF8, + 0xD8, 0x5B, 0xCE, 0x80, 0x18, 0x02, 0x98, 0xDF, 0xEB, 0x2B, 0xEF, 0x10, 0x6C, 0x1F, 0x94, 0x51, + 0x09, 0xC0, 0x56, 0xBE, 0x38, 0x7F, 0xE8, 0xE1, 0xEB, 0xF8, 0x71, 0x05, 0x97, 0xDF, 0x1C, 0x88, + 0xEC, 0x30, 0x96, 0xFF, 0xEA, 0xDD, 0x06, 0xA8, 0x77, 0x17, 0x48, 0xEB, 0x91, 0x81, 0x22, 0x70, + 0x46, 0xAA, 0x55, 0x22, 0x50, 0x24, 0xD3, 0x49, 0xBC, 0xC0, 0x52, 0xEC, 0xC2, 0xC1, 0xE4, 0xE5, + 0x00, 0x7C, 0xC6, 0x21, 0x50, 0xC0, 0xB9, 0x04, 0xE5, 0xB2, 0x58, 0xC1, 0xB2, 0x3C, 0x1A, 0x1A, + 0x00, 0x86, 0x83, 0x01, 0x40, 0x63, 0x35, 0x0D, 0x23, 0x14, 0x03, 0x13, 0x6F, 0x51, 0xA7, 0xE1, + 0x60, 0x92, 0xE0, 0x9D, 0x52, 0xA4, 0xE2, 0x12, 0x46, 0x81, 0x59, 0x69, 0x6E, 0xB2, 0xDE, 0x02, + 0x60, 0xDF, 0x47, 0x4C, 0x8B, 0x15, 0xF8, 0x23, 0x3D, 0x11, 0x04, 0x20, 0x83, 0x05, 0xB2, 0x02, + 0x1A, 0x67, 0x07, 0x8D, 0xB5, 0xCB, 0xEC, 0x0A, 0x99, 0x19, 0x0B, 0x12, 0x33, 0xFB, 0x4E, 0x01, + 0x18, 0x28, 0xC4, 0x14, 0x26, 0xA0, 0x04, 0x8E, 0xB1, 0xD6, 0x6E, 0x3B, 0xBA, 0x1E, 0x94, 0x7E, + 0x74, 0xEB, 0xFF, 0xFE, 0x27, 0x93, 0x31, 0x5E, 0xAD, 0xD7, 0xE5, 0x10, 0xA7, 0x5B, 0x6E, 0xBB, + 0x0C, 0x56, 0x52, 0x81, 0x22, 0x5E, 0xA3, 0x66, 0x01, 0xD0, 0xD4, 0x73, 0xAB, 0xE2, 0x88, 0x12, + 0x21, 0x16, 0xB2, 0x00, 0x00, 0x70, 0x00, 0x00, 0x04, 0x06, 0x00, 0xDD, 0x63, 0x00, 0x83, 0x1D, + 0x32, 0x11, 0x3B, 0xD1, 0xA4, 0x88, 0x3A, 0x9E, 0x7A, 0xBF, 0x40, 0x10, 0xA1, 0x00, 0x40, 0xE0, + 0x70, 0x0E, 0x5C, 0x0F, 0xDF, 0xF2, 0x78, 0x46, 0xD5, 0x82, 0x11, 0xF6, 0xBB, 0xFF, 0xC9, 0xFC, + 0x4E, 0xF0, 0x81, 0xC4, 0x20, 0x04, 0x0C, 0x11, 0x92, 0x84, 0x42, 0x69, 0x85, 0x26, 0xB1, 0x87, + 0xC7, 0xE9, 0x86, 0xE3, 0x11, 0x96, 0xF8, 0xC9, 0xCD, 0xA2, 0x39, 0x80, 0xC5, 0xA9, 0x9B, 0x40, + 0x41, 0x82, 0x00, 0x79, 0x82, 0x49, 0x81, 0x94, 0x0B, 0x69, 0x8F, 0x21, 0x31, 0x85, 0x42, 0x60, + 0xD0, 0x24, 0x59, 0x63, 0x90, 0x48, 0x9D, 0x04, 0xB5, 0xF3, 0x14, 0x55, 0x24, 0x50, 0xE6, 0x06, + 0x29, 0x7C, 0xA4, 0x2A, 0x41, 0x23, 0xB0, 0x8C, 0x14, 0xE8, 0x67, 0xA6, 0x38, 0x4B, 0x95, 0x6A, + 0x8D, 0x3D, 0x01, 0x3C, 0x90, 0xE6, 0x51, 0xFF, 0xFB, 0x92, 0x64, 0x8A, 0x8E, 0x84, 0x87, 0x34, + 0xCC, 0x03, 0xB9, 0x7B, 0x60, 0x2E, 0xA3, 0x79, 0xCD, 0x04, 0x05, 0x08, 0x13, 0x28, 0xD3, 0x30, + 0x4E, 0xE5, 0xEF, 0x90, 0xBA, 0x8F, 0x27, 0x68, 0x10, 0x18, 0x20, 0xDA, 0x2C, 0xB0, 0xAC, 0xF0, + 0x25, 0xD9, 0xA3, 0xE9, 0xA6, 0xA2, 0x45, 0x99, 0x61, 0x9B, 0x08, 0x82, 0x1A, 0x27, 0x65, 0xDD, + 0x80, 0xD3, 0x39, 0xBB, 0x49, 0xEA, 0xBF, 0x8E, 0xB5, 0xC9, 0x7E, 0xFF, 0xFF, 0xFF, 0xFD, 0xA5, + 0x7D, 0x4A, 0x65, 0x4E, 0x5B, 0xDC, 0x62, 0xFC, 0xC5, 0x4B, 0x1B, 0x47, 0x3A, 0x6F, 0x3D, 0xB8, + 0xC3, 0xA4, 0xE8, 0x95, 0xF2, 0xE2, 0x1F, 0x82, 0xE7, 0x1D, 0xDF, 0xFF, 0x49, 0xE5, 0xA7, 0x00, + 0x00, 0x00, 0x07, 0x00, 0xDF, 0xEF, 0x64, 0x4E, 0x49, 0x7D, 0x99, 0xE6, 0x90, 0x99, 0x55, 0x52, + 0x0B, 0x33, 0xE4, 0xDB, 0x57, 0x8D, 0xFF, 0xBD, 0x1A, 0x12, 0xE4, 0x1D, 0xF1, 0xD4, 0x95, 0x3E, + 0x4B, 0xEB, 0xEE, 0xC8, 0xBA, 0xB5, 0x4C, 0x7F, 0xF9, 0x5A, 0x1A, 0xC1, 0x72, 0x35, 0x04, 0x80, + 0x4B, 0xB8, 0xC5, 0x97, 0xC4, 0x74, 0x82, 0x31, 0xBC, 0xF4, 0x35, 0x94, 0x14, 0x31, 0x6C, 0x24, + 0x32, 0x72, 0x06, 0x38, 0x3C, 0xA2, 0x2E, 0x89, 0x90, 0x65, 0x68, 0x50, 0x1C, 0x31, 0x41, 0xD4, + 0x39, 0xCD, 0xD4, 0x30, 0x00, 0x9F, 0x36, 0xB5, 0x15, 0x31, 0x84, 0x09, 0x30, 0xA0, 0x18, 0x08, + 0xBA, 0x0E, 0x06, 0x18, 0x4A, 0x2A, 0x42, 0x24, 0x14, 0xA9, 0x4D, 0x03, 0x9C, 0x28, 0xDA, 0x47, + 0x96, 0xB9, 0xA1, 0xA7, 0x50, 0x60, 0xE1, 0x18, 0xF0, 0x08, 0xA6, 0x7A, 0x0D, 0x0E, 0x24, 0x19, + 0x09, 0x40, 0xE6, 0x69, 0x0E, 0xF9, 0x67, 0xBF, 0xFF, 0xC9, 0x46, 0x84, 0x96, 0x1D, 0x12, 0x80, + 0x52, 0x20, 0xA7, 0x42, 0x84, 0x04, 0xB0, 0x87, 0x25, 0x30, 0x89, 0x0D, 0x21, 0xF5, 0xA6, 0xF7, + 0xC0, 0xFD, 0xDC, 0x41, 0xAA, 0x39, 0xB0, 0x0C, 0xF3, 0x7F, 0xA9, 0x16, 0x4A, 0x98, 0xCC, 0x66, + 0x22, 0x5A, 0xA2, 0x08, 0xE4, 0x05, 0xA8, 0x2D, 0x65, 0xCC, 0xCC, 0x2D, 0x4B, 0x1D, 0xA1, 0xBA, + 0x88, 0x96, 0x88, 0x51, 0x98, 0x6F, 0x60, 0x40, 0x00, 0x03, 0x13, 0xF9, 0xC8, 0xBD, 0x55, 0x89, + 0xB5, 0x80, 0xEF, 0xDC, 0x54, 0xD6, 0x18, 0xB6, 0xC2, 0xC3, 0xC1, 0x56, 0xC0, 0xB4, 0x60, 0x62, + 0x38, 0xBF, 0x86, 0xB8, 0x69, 0x36, 0xB4, 0x71, 0xA2, 0x85, 0xEA, 0x56, 0xFF, 0xEC, 0xFA, 0x1C, + 0x3F, 0xCC, 0x6D, 0x06, 0x37, 0x60, 0x56, 0x10, 0xD2, 0xED, 0x04, 0x81, 0x66, 0xA6, 0x30, 0x06, + 0x21, 0x80, 0x66, 0x13, 0x0F, 0x06, 0x96, 0x89, 0x26, 0x10, 0x8E, 0x67, 0x2E, 0xEF, 0x06, 0x71, + 0x0C, 0x06, 0x37, 0x91, 0x82, 0xD2, 0xF0, 0x10, 0x04, 0x32, 0xCD, 0x82, 0x31, 0x44, 0x0D, 0x30, + 0xCC, 0x51, 0x35, 0x52, 0x58, 0x01, 0x14, 0x86, 0x08, 0x97, 0x86, 0x8C, 0xA8, 0x8C, 0x81, 0xD0, + 0x08, 0xEA, 0x18, 0x03, 0x8A, 0xE1, 0x59, 0x8C, 0xE9, 0xFF, 0xFB, 0x92, 0x64, 0x85, 0x8F, 0x54, + 0xC4, 0x35, 0x4B, 0x83, 0xBA, 0x6B, 0xE0, 0x32, 0x26, 0x49, 0x55, 0x09, 0x05, 0x6C, 0x53, 0xCC, + 0xD1, 0x2E, 0x0E, 0xEA, 0x2F, 0x88, 0xB6, 0x19, 0xE5, 0x60, 0xD3, 0x29, 0xD9, 0x57, 0x7C, 0x31, + 0x22, 0x17, 0xB3, 0x34, 0x23, 0x5D, 0x64, 0x27, 0xC7, 0x40, 0xB2, 0x83, 0x18, 0x51, 0x75, 0x37, + 0x54, 0xC2, 0x86, 0xE5, 0x90, 0xE6, 0xB1, 0xCA, 0xB5, 0x2A, 0x77, 0x28, 0x90, 0x14, 0x49, 0xCC, + 0x90, 0x8E, 0x63, 0x91, 0x03, 0xB5, 0x98, 0x82, 0xE6, 0xC5, 0xD0, 0x30, 0x32, 0x51, 0x19, 0xC0, + 0xCD, 0x5A, 0xCD, 0x48, 0x83, 0x69, 0x02, 0xB3, 0x0B, 0x67, 0xBF, 0xE6, 0xC3, 0xB4, 0x89, 0x11, + 0x35, 0xA4, 0x20, 0x29, 0x7D, 0x09, 0xA0, 0xC3, 0x11, 0xF9, 0x3F, 0x2E, 0xA0, 0xB4, 0x46, 0xC2, + 0x22, 0x10, 0x0C, 0xB8, 0xEA, 0x00, 0x00, 0x38, 0x00, 0x6C, 0x09, 0x00, 0x20, 0xAD, 0xBF, 0x10, + 0xE0, 0xE4, 0x47, 0xFF, 0xE9, 0xAB, 0x90, 0x8F, 0x06, 0x40, 0xE3, 0xEB, 0x9E, 0x82, 0x4F, 0x3C, + 0xA0, 0xF1, 0xDB, 0xD6, 0x4F, 0xE7, 0xAC, 0x80, 0x0B, 0x4E, 0xFF, 0xED, 0xFB, 0xF5, 0x24, 0xFA, + 0x64, 0x65, 0xB9, 0x53, 0x90, 0x9C, 0xB1, 0x3C, 0x35, 0x58, 0xC7, 0x0C, 0x9A, 0xA2, 0x56, 0x98, + 0x80, 0x06, 0x98, 0x22, 0x2B, 0x86, 0x54, 0xC6, 0x01, 0x12, 0x26, 0x29, 0x70, 0xA6, 0x7E, 0x0D, + 0x86, 0x39, 0x86, 0xE6, 0x79, 0x91, 0xC6, 0x17, 0x03, 0xE6, 0x11, 0xA9, 0x66, 0x15, 0x86, 0xE6, + 0x04, 0x97, 0x47, 0x18, 0x70, 0xE6, 0x29, 0x07, 0x86, 0x1C, 0x87, 0x62, 0xF6, 0xC1, 0x46, 0x00, + 0x53, 0xD3, 0xA8, 0x61, 0xD1, 0x12, 0x96, 0x32, 0x05, 0x68, 0xD7, 0x44, 0x25, 0x92, 0xFD, 0xD9, + 0x02, 0x28, 0x62, 0xA5, 0x43, 0xE1, 0x40, 0xCE, 0x89, 0xA1, 0x76, 0xBE, 0x15, 0x80, 0x38, 0x75, + 0x8B, 0x4A, 0x6F, 0xDE, 0x77, 0xFE, 0x6C, 0xCE, 0x8D, 0x66, 0xE2, 0x30, 0x87, 0x10, 0x31, 0x76, + 0x87, 0xBB, 0x00, 0x01, 0x9A, 0x83, 0x23, 0x41, 0x16, 0x18, 0xC0, 0x9B, 0x74, 0xFB, 0x5A, 0xDD, + 0x9C, 0x54, 0x7A, 0xC7, 0xFF, 0xFE, 0x1D, 0xFC, 0x3F, 0xEA, 0x67, 0x1A, 0x91, 0xE3, 0x12, 0x7E, + 0xA8, 0xF9, 0x94, 0xA0, 0x70, 0x3A, 0x4D, 0xBA, 0x13, 0x9F, 0xFA, 0xDA, 0x9B, 0xE4, 0xAA, 0x52, + 0x86, 0x10, 0x30, 0x15, 0xF4, 0x8C, 0xC2, 0x3A, 0x00, 0x44, 0x00, 0x40, 0x37, 0x08, 0x25, 0x0A, + 0xA7, 0xFF, 0x5F, 0x22, 0xF3, 0xD8, 0xED, 0x45, 0x0D, 0x90, 0xFF, 0x92, 0x2E, 0xF3, 0xCF, 0x99, + 0x7F, 0xFF, 0x0E, 0x10, 0xC4, 0xE0, 0x65, 0xEE, 0x40, 0xEF, 0xB2, 0x7C, 0xB8, 0xF7, 0xA3, 0x3E, + 0xFD, 0xE8, 0x28, 0xBC, 0xC1, 0x21, 0x83, 0xA7, 0x0F, 0x4C, 0x2A, 0x0C, 0x00, 0x33, 0xCC, 0xDE, + 0x86, 0x32, 0x38, 0xB0, 0xEA, 0x17, 0x03, 0x80, 0x8F, 0x8C, 0x18, 0x69, 0x12, 0xFA, 0x8D, 0x03, + 0x4C, 0x6C, 0xBF, 0x07, 0x6E, 0xC4, 0x24, 0xC3, 0xA5, 0xE2, 0x83, 0xFF, 0xFB, 0x92, 0x64, 0x79, + 0x0F, 0x14, 0xF7, 0x35, 0x4C, 0x03, 0x1D, 0xD0, 0x60, 0x2B, 0xA3, 0xC9, 0xC8, 0x04, 0x08, 0x02, + 0x92, 0xA8, 0xD5, 0x32, 0x0E, 0x77, 0x2C, 0x40, 0xC2, 0x0E, 0x67, 0x50, 0x23, 0x15, 0xD8, 0x02, + 0x01, 0x91, 0x11, 0x4A, 0x64, 0x68, 0x1F, 0x07, 0x18, 0x18, 0x13, 0x2B, 0x08, 0x54, 0x84, 0x7D, + 0xA5, 0x06, 0x46, 0xCD, 0x5E, 0x22, 0x75, 0xA1, 0x6B, 0x60, 0x34, 0x44, 0xDF, 0x38, 0x27, 0x59, + 0xE2, 0x52, 0x89, 0xF8, 0xE7, 0x07, 0x03, 0x2E, 0x8E, 0xA8, 0xE7, 0x6A, 0x5E, 0xFA, 0xCC, 0x65, + 0x08, 0x40, 0x61, 0xA9, 0x79, 0xE0, 0xEE, 0x01, 0x02, 0x83, 0xBC, 0x4C, 0x69, 0x3C, 0x29, 0x15, + 0x47, 0x8E, 0x72, 0x21, 0x88, 0xC4, 0xD3, 0x91, 0x23, 0xB3, 0x87, 0x3F, 0x0B, 0x16, 0xAF, 0x73, + 0xEE, 0xD1, 0xE5, 0xB9, 0x8E, 0xD2, 0xD2, 0x7F, 0x3D, 0xAF, 0xBE, 0xAF, 0xCA, 0x7C, 0xD2, 0xEB, + 0x7A, 0x9B, 0x61, 0x9B, 0x89, 0x4E, 0x42, 0x5C, 0x28, 0x19, 0x2A, 0xED, 0xF0, 0x00, 0x03, 0x14, + 0x00, 0x77, 0xF0, 0x4A, 0xC5, 0x7F, 0xB7, 0x96, 0x34, 0x46, 0xCC, 0x88, 0x38, 0xC1, 0xDD, 0x61, + 0x01, 0x89, 0x49, 0x21, 0xE3, 0x06, 0xD4, 0x57, 0xF1, 0x60, 0xA1, 0x40, 0x8D, 0x04, 0x85, 0xA7, + 0x40, 0x62, 0x44, 0x07, 0xF1, 0xC6, 0x6D, 0x96, 0xCA, 0x82, 0x5A, 0x10, 0xFA, 0x55, 0x8E, 0x97, + 0x80, 0xD3, 0x93, 0xC8, 0xC3, 0x60, 0xD4, 0xC2, 0xA1, 0x6C, 0xCB, 0x20, 0x70, 0x2C, 0x0D, 0x19, + 0x73, 0x6D, 0x18, 0xF4, 0x39, 0x18, 0x3E, 0x44, 0x18, 0x00, 0x35, 0x80, 0x80, 0xA3, 0x0F, 0x85, + 0x63, 0x34, 0xC0, 0xA1, 0x08, 0x04, 0x70, 0xF2, 0xC6, 0x4C, 0x1E, 0x81, 0x48, 0xD0, 0x13, 0x6E, + 0xBA, 0x8C, 0x19, 0x10, 0xE2, 0x62, 0x10, 0x20, 0xC4, 0xD0, 0x26, 0x16, 0x60, 0x00, 0x3E, 0x34, + 0x5B, 0x09, 0x37, 0x92, 0x77, 0x4C, 0xD4, 0x46, 0xF4, 0x50, 0x73, 0xA6, 0xEA, 0x75, 0xEC, 0x1E, + 0x0A, 0x98, 0x85, 0x40, 0x9C, 0xB2, 0x99, 0xBC, 0x91, 0x4E, 0xEB, 0x09, 0x50, 0x21, 0x43, 0x4C, + 0x64, 0xEB, 0x38, 0x46, 0x8B, 0xB7, 0x81, 0x84, 0xAB, 0xD9, 0x57, 0x8B, 0xA8, 0xA0, 0x55, 0xAB, + 0x0F, 0x18, 0x4A, 0xA5, 0x02, 0x4A, 0x6F, 0xED, 0x66, 0x17, 0xBA, 0xF5, 0x53, 0x6B, 0x30, 0xA7, + 0xDB, 0x75, 0x32, 0x5D, 0xCE, 0x06, 0x52, 0xCE, 0x16, 0x8C, 0x4A, 0x7D, 0x24, 0xA3, 0xCE, 0xF0, + 0x52, 0xDF, 0x35, 0x9D, 0x4E, 0xF4, 0x00, 0x0C, 0x0C, 0x00, 0x1F, 0xF9, 0x40, 0x49, 0xFF, 0xB6, + 0x55, 0x88, 0x65, 0x45, 0xB8, 0x58, 0xD6, 0xB1, 0x84, 0x45, 0xCC, 0x86, 0x49, 0x88, 0x2C, 0xEB, + 0xA7, 0x41, 0x57, 0x20, 0x04, 0xE8, 0x26, 0x2B, 0x53, 0x83, 0xCE, 0x91, 0x1F, 0x52, 0xFC, 0xA5, + 0x05, 0x0A, 0x27, 0x20, 0x02, 0x79, 0x1A, 0x33, 0x00, 0xC2, 0x73, 0x3F, 0xA4, 0x53, 0x0B, 0xC6, + 0xD3, 0x01, 0xC4, 0xE0, 0x35, 0x6A, 0x61, 0x81, 0x3A, 0x6B, 0x9E, 0x7E, 0x69, 0xFF, 0xFB, 0x92, + 0x64, 0x6F, 0x8F, 0x74, 0xBF, 0x35, 0x4D, 0x03, 0xB9, 0x7C, 0xB0, 0x30, 0xA3, 0xD9, 0x94, 0x1D, + 0x25, 0x92, 0x14, 0x98, 0xCF, 0x30, 0x0E, 0xED, 0xF1, 0x48, 0xB4, 0x99, 0xE6, 0x20, 0x20, 0x15, + 0x48, 0xF0, 0xC2, 0x63, 0x78, 0x8C, 0x6A, 0xF8, 0xE0, 0x09, 0x04, 0x8C, 0x1C, 0x52, 0x0C, 0x45, + 0x0B, 0x0C, 0x19, 0x09, 0xCF, 0x1D, 0x2B, 0x8C, 0x3F, 0x01, 0x04, 0x47, 0x78, 0x44, 0x94, 0x55, + 0x03, 0x4C, 0x16, 0x16, 0x15, 0xD9, 0x80, 0x90, 0x87, 0x7F, 0x39, 0xE6, 0x04, 0xA0, 0x50, 0x34, + 0x81, 0x46, 0x60, 0x32, 0x87, 0xA0, 0x98, 0xD0, 0xC2, 0x94, 0x39, 0x1A, 0xE1, 0x0B, 0x59, 0x14, + 0x08, 0x08, 0x35, 0x47, 0xA1, 0x40, 0xF8, 0x39, 0xA2, 0x29, 0x08, 0xFA, 0x64, 0xCF, 0xDD, 0x9B, + 0x6A, 0x82, 0x8A, 0x06, 0x16, 0x00, 0xFB, 0x95, 0xB8, 0x35, 0x16, 0x1E, 0x10, 0x18, 0xDC, 0x51, + 0xAE, 0x7C, 0xB7, 0x6F, 0x93, 0x8A, 0xB4, 0xEA, 0x7B, 0x7E, 0xB5, 0x23, 0xED, 0x1F, 0xE7, 0x36, + 0xDF, 0xF2, 0x16, 0xDD, 0xE7, 0x0C, 0xAE, 0xDB, 0x96, 0x6E, 0x4B, 0x15, 0xC0, 0x3B, 0x82, 0xEC, + 0xC5, 0x78, 0x3D, 0x77, 0xF4, 0x4C, 0x0F, 0x36, 0xA0, 0x87, 0x82, 0xC8, 0x57, 0x93, 0xE2, 0x42, + 0x3C, 0x43, 0xF4, 0x33, 0xAC, 0xBA, 0x97, 0xAB, 0x72, 0xF2, 0x95, 0x0A, 0x10, 0x7B, 0x3C, 0x49, + 0xB4, 0x11, 0xA3, 0xC6, 0x8B, 0xC3, 0x61, 0x81, 0xA1, 0x84, 0xD4, 0x79, 0x1F, 0xAF, 0xA3, 0x74, + 0x15, 0xE1, 0xE1, 0x8A, 0x16, 0x59, 0x1F, 0x8B, 0x31, 0x43, 0xA2, 0x80, 0x8A, 0x46, 0x53, 0x22, + 0x43, 0x08, 0xA9, 0x83, 0x14, 0x07, 0x63, 0x0D, 0xCE, 0x02, 0xB4, 0x88, 0x88, 0x53, 0x3C, 0x69, + 0x7B, 0x16, 0x67, 0xCC, 0x79, 0x05, 0x4C, 0x01, 0x05, 0xC4, 0x21, 0xA1, 0x8C, 0x26, 0x61, 0x89, + 0x81, 0x00, 0x10, 0xBB, 0x38, 0xC8, 0xFC, 0x30, 0x30, 0x27, 0x31, 0x3D, 0x93, 0x32, 0x04, 0x28, + 0x64, 0x06, 0x07, 0x0A, 0x69, 0x9A, 0x28, 0xAC, 0xE5, 0x88, 0x6A, 0xA6, 0x64, 0x5A, 0x5D, 0x10, + 0x1E, 0x5E, 0xCA, 0xF8, 0xE4, 0x03, 0x1A, 0x46, 0x48, 0xC9, 0xD4, 0x77, 0x8A, 0x92, 0x99, 0x2A, + 0x42, 0x00, 0x9D, 0x4B, 0xA2, 0x4C, 0x56, 0x09, 0x47, 0xA8, 0x5D, 0x59, 0x64, 0xC9, 0xAF, 0x03, + 0x34, 0x61, 0xA7, 0x03, 0xA3, 0xA7, 0x61, 0x94, 0x00, 0x06, 0x02, 0xFF, 0x87, 0x0B, 0x86, 0xC8, + 0x08, 0xAD, 0xD8, 0x79, 0xC8, 0xAF, 0x0C, 0x34, 0x09, 0xD9, 0xCB, 0x3F, 0xFF, 0xFF, 0xFF, 0xF9, + 0x4A, 0xAF, 0xEF, 0xAD, 0x12, 0x8E, 0xC4, 0xA2, 0x71, 0x69, 0x55, 0x5A, 0x2A, 0xA5, 0x19, 0xA1, + 0x6A, 0x95, 0xB9, 0x83, 0x23, 0x6F, 0xA3, 0x65, 0xF1, 0x67, 0x42, 0xA0, 0x99, 0xA0, 0x40, 0x27, + 0xFD, 0xE8, 0x23, 0x33, 0x85, 0x08, 0x0A, 0xC6, 0xAD, 0xD1, 0xF8, 0x9C, 0x5D, 0x1B, 0x14, 0x2E, + 0x84, 0x8E, 0xD1, 0x25, 0xEB, 0xDF, 0x28, 0x35, 0x7B, 0xCE, 0x4D, 0x87, 0x8E, 0x1F, 0x1E, 0xFF, + 0xFB, 0x92, 0x64, 0x61, 0x0F, 0x55, 0x05, 0x33, 0xCC, 0x03, 0x3D, 0xD0, 0x70, 0x2B, 0xA6, 0x89, + 0x31, 0x04, 0x07, 0x2E, 0x92, 0x98, 0xD1, 0x32, 0x0E, 0xF3, 0x26, 0xC0, 0xC1, 0x19, 0xA5, 0xA0, + 0x15, 0x89, 0x39, 0x8E, 0x1D, 0xC7, 0x04, 0x51, 0x70, 0x64, 0x1F, 0x01, 0x13, 0x17, 0x70, 0xE0, + 0x2E, 0x67, 0x5C, 0x3A, 0x30, 0x5F, 0x18, 0x78, 0x83, 0x18, 0x84, 0x1A, 0xAB, 0x79, 0xC8, 0x71, + 0x51, 0x86, 0xC7, 0x86, 0xA6, 0x29, 0x99, 0xD8, 0x48, 0x16, 0x03, 0x18, 0x3D, 0x9A, 0x60, 0xA0, + 0xD8, 0x89, 0xC8, 0x76, 0x86, 0x09, 0x91, 0x01, 0x06, 0x7A, 0x8D, 0x84, 0xFA, 0x44, 0x01, 0xDE, + 0xD4, 0xC1, 0x72, 0x45, 0xE3, 0x69, 0x26, 0x71, 0xCD, 0x48, 0x95, 0x60, 0xE4, 0x9A, 0x21, 0xD7, + 0x63, 0xE8, 0x54, 0xB8, 0x8A, 0x37, 0x1C, 0xCD, 0x2D, 0x67, 0xA6, 0x93, 0x11, 0xE2, 0x8F, 0xE1, + 0x8A, 0x66, 0x51, 0x54, 0xC9, 0x99, 0x85, 0x84, 0x48, 0xE0, 0x47, 0x00, 0x35, 0xAA, 0x1B, 0xB2, + 0x23, 0x52, 0x0D, 0x83, 0x9E, 0xEA, 0x54, 0xC5, 0x2F, 0x3A, 0xF3, 0xF5, 0xD6, 0xE6, 0x10, 0xEF, + 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFC, 0xBE, 0xB4, 0x79, 0x5A, 0x6C, 0x28, 0x7C, 0x1B, 0x2D, + 0x53, 0x86, 0x74, 0x5F, 0x07, 0x42, 0x5B, 0x96, 0x9A, 0x4C, 0xBE, 0xEB, 0x67, 0xA4, 0x2A, 0x88, + 0xC7, 0xF0, 0x03, 0x00, 0x0C, 0x7E, 0x7F, 0x1E, 0x00, 0x90, 0xA4, 0x75, 0xDF, 0xF0, 0xC4, 0x0E, + 0x57, 0xDC, 0x9B, 0xDA, 0x66, 0xF7, 0xFE, 0x4E, 0x31, 0x33, 0x23, 0xAB, 0x9F, 0xF5, 0x17, 0x0E, + 0x2E, 0x41, 0x7F, 0xA1, 0x39, 0xDF, 0xFD, 0x13, 0xEF, 0xC5, 0x87, 0x50, 0x44, 0x3B, 0xE8, 0xC6, + 0x40, 0x55, 0x2A, 0x2E, 0xE9, 0x81, 0x20, 0xE1, 0xB5, 0x10, 0x71, 0x8E, 0x62, 0x81, 0x98, 0x4C, + 0xB1, 0x93, 0x02, 0xD1, 0x30, 0x82, 0x73, 0x84, 0x8E, 0x61, 0x50, 0x4C, 0x30, 0x1B, 0x80, 0x8B, + 0xA5, 0x05, 0x1E, 0x06, 0xCC, 0x15, 0x02, 0x0C, 0x3E, 0x2D, 0x8D, 0x3B, 0x02, 0x4C, 0x01, 0x04, + 0x8C, 0x10, 0x1E, 0x07, 0xE0, 0x00, 0x83, 0x98, 0xA0, 0xAE, 0x00, 0xA8, 0x61, 0x6A, 0xCE, 0x02, + 0x0F, 0xB1, 0xD2, 0xC1, 0x80, 0xE0, 0x75, 0xCC, 0x84, 0xB6, 0xC2, 0x30, 0x70, 0x05, 0xDC, 0x48, + 0x78, 0x19, 0x02, 0x88, 0xB1, 0xB6, 0x52, 0xF7, 0x27, 0x2D, 0xC8, 0xE3, 0x4F, 0x93, 0x54, 0xCA, + 0x96, 0x07, 0x1E, 0x0A, 0x11, 0x9E, 0x40, 0x95, 0x20, 0x0F, 0xA8, 0x50, 0x80, 0xE6, 0xC6, 0x24, + 0xC3, 0x5A, 0x79, 0x6A, 0x35, 0x09, 0x13, 0x1B, 0x69, 0xB1, 0x88, 0x57, 0xFF, 0xFF, 0xE1, 0xCC, + 0x30, 0xB9, 0x49, 0x63, 0x58, 0x65, 0xB8, 0xF4, 0x7F, 0xD5, 0x55, 0x56, 0x44, 0x89, 0x8C, 0xAE, + 0x82, 0x1C, 0x8F, 0xB7, 0xFE, 0xB4, 0x6A, 0xFD, 0x49, 0x4D, 0xC6, 0x94, 0xC1, 0xE0, 0x4E, 0x80, + 0x28, 0x00, 0x00, 0x00, 0x12, 0x00, 0x6B, 0xF7, 0xF0, 0xB0, 0x5C, 0x52, 0x13, 0x3F, 0xD9, 0xA2, + 0x7B, 0xFF, 0xFB, 0x92, 0x64, 0x57, 0x0F, 0x04, 0xE1, 0x34, 0xCC, 0x03, 0xBA, 0xC3, 0xB0, 0x31, + 0xE5, 0xB9, 0xBC, 0x1C, 0xC2, 0x74, 0x52, 0x48, 0xD1, 0x2E, 0x0E, 0xEF, 0x46, 0x88, 0xBD, 0x97, + 0xA5, 0xE0, 0xA4, 0x09, 0xE8, 0x95, 0x47, 0x91, 0x30, 0x0C, 0x57, 0xE8, 0x47, 0x10, 0xDD, 0x42, + 0x89, 0x30, 0x93, 0x1C, 0x58, 0xAF, 0xEA, 0x74, 0x3A, 0x7F, 0xB2, 0xB7, 0xD5, 0x31, 0x85, 0x89, + 0x84, 0x5B, 0x8D, 0x12, 0x0C, 0x69, 0x60, 0x92, 0x04, 0xE7, 0x57, 0xB4, 0xCE, 0x65, 0x84, 0xC2, + 0xD7, 0x20, 0x0D, 0xAE, 0x18, 0x84, 0x3F, 0x9A, 0x62, 0x85, 0x1C, 0x2A, 0xA1, 0x84, 0xAC, 0x9A, + 0x00, 0xB9, 0x10, 0x71, 0x8A, 0x9E, 0x18, 0x69, 0xD1, 0xA6, 0xCD, 0x1E, 0x9C, 0xCA, 0x6E, 0x68, + 0xD4, 0x26, 0x9A, 0xFE, 0x28, 0x12, 0xC0, 0x9A, 0xF8, 0x70, 0xE8, 0x91, 0x75, 0x6E, 0x97, 0xB8, + 0x1C, 0xF8, 0x94, 0x10, 0xE9, 0x61, 0x62, 0x46, 0x2C, 0xF9, 0xD5, 0xF0, 0x5A, 0xD8, 0x8A, 0x5B, + 0x39, 0x80, 0xA1, 0xAE, 0x53, 0x72, 0x82, 0xEB, 0xC0, 0xF2, 0x6E, 0xFD, 0xF5, 0x8E, 0xE3, 0x29, + 0xE5, 0x2D, 0x6E, 0x2B, 0x15, 0xFC, 0x42, 0x48, 0xE0, 0x94, 0x45, 0xA5, 0x7A, 0x5A, 0x7C, 0xAA, + 0x8A, 0x19, 0x75, 0xE6, 0xEF, 0x6F, 0xFF, 0xFE, 0xB5, 0xEC, 0xE2, 0x12, 0xA9, 0xFB, 0x7A, 0xA7, + 0xE6, 0xEA, 0xC8, 0x33, 0xAF, 0x4B, 0x05, 0xAF, 0x96, 0x4C, 0xBC, 0x58, 0xD4, 0xBB, 0x1D, 0x55, + 0xFB, 0x96, 0x29, 0xA9, 0x9D, 0xB9, 0xC5, 0xC0, 0x10, 0xC0, 0x02, 0x08, 0xDB, 0xFB, 0x28, 0xAC, + 0x02, 0xC1, 0x5C, 0x20, 0x5E, 0x15, 0x20, 0x4F, 0xA9, 0x28, 0x39, 0xEC, 0x2C, 0x47, 0x5F, 0xF0, + 0xD2, 0xB1, 0x5A, 0x7B, 0x32, 0xAD, 0x0D, 0x11, 0x86, 0xDA, 0xBA, 0x97, 0xFE, 0x87, 0xF6, 0xDF, + 0x70, 0x83, 0x97, 0x40, 0x39, 0x2C, 0xCD, 0x6F, 0xCC, 0x18, 0x28, 0xCE, 0xE2, 0x67, 0x0C, 0x9C, + 0x27, 0x0D, 0x9B, 0x42, 0x3C, 0x72, 0x24, 0x10, 0x8D, 0x38, 0x04, 0x78, 0xE1, 0x65, 0x43, 0x25, + 0x93, 0x12, 0x64, 0xC3, 0x41, 0xD3, 0x47, 0x0D, 0x4C, 0x74, 0x44, 0x22, 0x4A, 0x19, 0x59, 0xA0, + 0xE4, 0x00, 0x83, 0x23, 0xC0, 0xD9, 0x4B, 0x66, 0xA0, 0x43, 0x95, 0x26, 0x8B, 0xD0, 0xF9, 0xB2, + 0x14, 0x10, 0x88, 0x45, 0x17, 0xC8, 0x98, 0x11, 0x94, 0x92, 0x6E, 0xA1, 0x99, 0x20, 0xE1, 0x40, + 0xE8, 0x3C, 0xD6, 0x10, 0x1E, 0x8F, 0x6E, 0x64, 0x4A, 0x38, 0xD8, 0x60, 0x19, 0x46, 0x32, 0x94, + 0x84, 0x64, 0x6A, 0xA3, 0x1E, 0x87, 0x1E, 0x78, 0x10, 0x68, 0x4A, 0x80, 0x37, 0xED, 0x6D, 0x4E, + 0xD8, 0x15, 0x35, 0x2C, 0x41, 0xDE, 0x86, 0xB2, 0xCB, 0xFF, 0x5F, 0x95, 0x9A, 0xB5, 0xA7, 0xAC, + 0xE1, 0xF6, 0x39, 0xFC, 0xD6, 0x71, 0x45, 0x3F, 0x1D, 0xB1, 0x48, 0xA3, 0xCE, 0xF5, 0x17, 0xFE, + 0x5F, 0xAE, 0x6E, 0x2B, 0x29, 0x9A, 0xB6, 0x40, 0x00, 0x00, 0x08, 0x00, 0x08, 0x37, 0x48, 0xCB, + 0x10, 0x47, 0x50, 0xFF, 0xFB, 0x92, 0x64, 0x4E, 0x0F, 0xC4, 0x7F, 0x34, 0xCA, 0x83, 0xBC, 0xD0, + 0xC0, 0x31, 0xC5, 0x79, 0x77, 0x08, 0xC7, 0x2E, 0x13, 0x90, 0xD1, 0x22, 0x0F, 0x6F, 0x28, 0x88, + 0xB7, 0x8B, 0xA6, 0x04, 0x76, 0x0D, 0x0A, 0x0C, 0xAF, 0xF4, 0xA4, 0xF9, 0xDB, 0x06, 0x29, 0xE0, + 0x08, 0x46, 0x8F, 0x04, 0x05, 0xB3, 0xFD, 0x48, 0xEE, 0xC8, 0x34, 0x61, 0xC1, 0x22, 0x38, 0x4D, + 0x48, 0x4F, 0xCF, 0xED, 0xFE, 0x9E, 0x8B, 0xF2, 0xAC, 0x8B, 0x9E, 0xF0, 0xF8, 0x5C, 0x18, 0x46, + 0x81, 0x18, 0xD2, 0x6C, 0xAB, 0x4C, 0x12, 0x88, 0x88, 0xC2, 0x1C, 0x3A, 0x0C, 0x80, 0x81, 0x1C, + 0xC0, 0x90, 0x02, 0xCC, 0x1E, 0xC9, 0x64, 0xC3, 0x74, 0x0F, 0x0C, 0x55, 0x82, 0x64, 0xE0, 0x44, + 0x0C, 0x84, 0x60, 0xC0, 0xED, 0x0F, 0x24, 0x18, 0x42, 0xDC, 0x6C, 0x03, 0x46, 0x02, 0x40, 0x61, + 0x43, 0xA4, 0xD9, 0x36, 0xCB, 0x38, 0x80, 0x50, 0x81, 0xD0, 0x79, 0x4B, 0x57, 0x60, 0x88, 0xB4, + 0x7E, 0x02, 0x8C, 0x8D, 0xC2, 0x82, 0x21, 0xD0, 0xBA, 0x40, 0x81, 0xD9, 0x99, 0x6A, 0x52, 0x4C, + 0xA8, 0x79, 0x92, 0x29, 0x58, 0xF2, 0x14, 0x6F, 0x2F, 0xCC, 0x3A, 0xA1, 0xA8, 0x91, 0x2D, 0x56, + 0x40, 0x85, 0x41, 0x14, 0x22, 0x22, 0xA8, 0x83, 0x8D, 0x31, 0x02, 0x71, 0x46, 0xB4, 0x08, 0x39, + 0x81, 0x26, 0x69, 0x7D, 0x01, 0x4D, 0xC8, 0xE9, 0xE5, 0x11, 0x3A, 0x5D, 0x7F, 0xFF, 0xE5, 0x57, + 0x98, 0xFD, 0x2E, 0xB9, 0xF3, 0xDD, 0xFD, 0x6F, 0x8F, 0xB4, 0x5A, 0xED, 0x2C, 0x7A, 0x1A, 0x97, + 0x63, 0xAF, 0xCF, 0xFF, 0x95, 0x65, 0x32, 0x9B, 0x32, 0x85, 0x00, 0xE4, 0x59, 0xD4, 0x64, 0x3A, + 0x16, 0x3C, 0x7C, 0x94, 0x07, 0x13, 0x9E, 0x30, 0x86, 0x3C, 0x10, 0x13, 0xAB, 0x19, 0x54, 0x70, + 0xAA, 0x68, 0x47, 0xFE, 0x94, 0x82, 0x82, 0x43, 0x4E, 0x91, 0x05, 0xAF, 0x39, 0x11, 0x78, 0xF0, + 0xD0, 0xE7, 0xE4, 0xA1, 0xE0, 0x0F, 0x91, 0x14, 0x08, 0x8C, 0x48, 0x46, 0xCF, 0x79, 0x64, 0x0D, + 0x55, 0x5E, 0x4C, 0xE8, 0x0D, 0xCC, 0xEA, 0x4E, 0x0D, 0x26, 0x3A, 0x8E, 0x0A, 0x52, 0x0C, 0xA7, + 0x3A, 0x4C, 0xA4, 0x2A, 0x04, 0x40, 0x79, 0x82, 0x82, 0x59, 0x8E, 0xC3, 0xD9, 0x8E, 0x03, 0x01, + 0x82, 0xC1, 0x79, 0x87, 0x22, 0x29, 0x73, 0x8C, 0x19, 0x04, 0x47, 0xD2, 0x66, 0xEB, 0x06, 0xD3, + 0x4C, 0x11, 0x40, 0x87, 0x26, 0xC2, 0xCA, 0x50, 0xA5, 0xD8, 0xAE, 0x0A, 0x03, 0x2E, 0x9A, 0x00, + 0x49, 0x44, 0x03, 0x04, 0x0C, 0x10, 0x89, 0x25, 0x3E, 0x03, 0x41, 0x33, 0x54, 0x61, 0xDF, 0x11, + 0x06, 0x44, 0x73, 0xAC, 0xB9, 0x50, 0x86, 0xE3, 0x9C, 0x25, 0x30, 0x20, 0x62, 0x55, 0x09, 0x06, + 0x20, 0x11, 0x3E, 0x41, 0xA4, 0x21, 0x02, 0xBC, 0x8A, 0x87, 0x44, 0x1C, 0x68, 0x5C, 0x47, 0xB9, + 0xFD, 0x65, 0xAF, 0x24, 0x1F, 0xFF, 0xF6, 0x95, 0xF2, 0xB8, 0xD6, 0xFF, 0xC6, 0x06, 0x44, 0xEE, + 0x06, 0x0C, 0x1D, 0xE8, 0x2A, 0xFF, 0xFB, 0x92, 0x64, 0x47, 0x0E, 0x84, 0xBB, 0x34, 0xC8, 0x03, + 0xB9, 0x43, 0xE0, 0x2E, 0x83, 0xF9, 0x73, 0x09, 0x23, 0x26, 0x14, 0x00, 0xD3, 0x22, 0x6E, 0xE5, + 0x4F, 0x80, 0xB7, 0x8F, 0xA6, 0x68, 0x04, 0x8C, 0x68, 0xBB, 0x96, 0x19, 0x04, 0xCF, 0xAA, 0x4C, + 0xAB, 0xFD, 0x00, 0x00, 0x4C, 0x00, 0x04, 0x13, 0xE2, 0x44, 0x72, 0x5B, 0x8F, 0xA0, 0x0F, 0x03, + 0x87, 0xC2, 0x85, 0x43, 0x9F, 0x9C, 0x4D, 0x37, 0x28, 0x8D, 0x42, 0x49, 0x21, 0x57, 0x43, 0x64, + 0x4A, 0xEB, 0x87, 0x03, 0x7F, 0x07, 0x06, 0x34, 0xEC, 0xA3, 0xB5, 0x7D, 0x87, 0x95, 0xAF, 0x52, + 0x54, 0x01, 0x90, 0x04, 0x10, 0x18, 0x04, 0xB9, 0x1F, 0x1C, 0x5A, 0x05, 0xA2, 0xD3, 0x0B, 0x04, + 0xB3, 0x28, 0x87, 0x73, 0x30, 0x90, 0x23, 0x47, 0xDB, 0xA3, 0x2A, 0x98, 0x03, 0x03, 0x97, 0xD0, + 0x70, 0xF4, 0x0E, 0x1F, 0xCC, 0xB3, 0x2D, 0x0C, 0x9E, 0x16, 0x8C, 0x8E, 0x0B, 0x4C, 0x53, 0x24, + 0x0C, 0x0E, 0x0E, 0x92, 0xED, 0x8D, 0x57, 0x7F, 0x88, 0x82, 0x4D, 0x57, 0x61, 0x2C, 0x62, 0x4C, + 0xF5, 0xA1, 0xA3, 0x3C, 0x18, 0xD2, 0x4B, 0x2A, 0xA6, 0xCA, 0x06, 0x02, 0x44, 0x47, 0x48, 0x30, + 0x03, 0x1E, 0x60, 0x75, 0xA6, 0x41, 0x43, 0x44, 0x29, 0x84, 0x2D, 0x23, 0x62, 0xF9, 0x4B, 0x8A, + 0x82, 0x82, 0x0F, 0x52, 0x22, 0xD8, 0x0F, 0xAB, 0x00, 0xCD, 0x16, 0x2B, 0x54, 0xAC, 0x61, 0x10, + 0x57, 0xB1, 0x9A, 0xAA, 0x0A, 0xAA, 0xF1, 0x90, 0xD4, 0xD9, 0x6C, 0x31, 0x6F, 0xEF, 0x2F, 0xFB, + 0x19, 0x6C, 0xF2, 0x80, 0xDE, 0x3E, 0x71, 0x58, 0x10, 0x68, 0xC4, 0x00, 0x51, 0x2F, 0x11, 0xC2, + 0xD9, 0x20, 0x2E, 0x13, 0x5D, 0x6F, 0xBD, 0xAB, 0xF7, 0x0E, 0xEB, 0xFF, 0xFF, 0xF3, 0x5A, 0xB6, + 0x50, 0x60, 0x00, 0x02, 0x26, 0x81, 0xE9, 0x13, 0x5B, 0xEA, 0x40, 0x70, 0xB2, 0x33, 0x1E, 0x59, + 0xEF, 0xA7, 0x5C, 0xE4, 0x8E, 0x09, 0xC4, 0xB6, 0xC3, 0x9B, 0xFF, 0xB7, 0xB1, 0xA8, 0x9B, 0x01, + 0x48, 0x1C, 0x51, 0x0A, 0x63, 0x69, 0x46, 0x43, 0xB7, 0xB7, 0xD7, 0xFF, 0x4E, 0xDE, 0x51, 0x01, + 0x04, 0x00, 0x11, 0x81, 0xEA, 0xA1, 0xDF, 0x2B, 0xC9, 0x90, 0x46, 0xC8, 0x43, 0x7E, 0x60, 0xEA, + 0x9E, 0x6B, 0x91, 0x46, 0x6B, 0xAD, 0x32, 0x60, 0x92, 0x94, 0x63, 0x21, 0x04, 0x63, 0x88, 0x58, + 0x63, 0xA0, 0x78, 0x61, 0x70, 0xDC, 0x04, 0x06, 0xCC, 0xA5, 0x15, 0x4C, 0x7C, 0x12, 0x4B, 0x98, + 0x10, 0x01, 0x07, 0x81, 0x40, 0x03, 0x12, 0xB7, 0xD7, 0xB3, 0x05, 0x2F, 0x83, 0xCA, 0xE1, 0x2B, + 0xD5, 0xEA, 0xBF, 0x12, 0x55, 0x64, 0xA7, 0x1B, 0xA2, 0xD4, 0x92, 0x14, 0xC4, 0x45, 0x14, 0x11, + 0x90, 0x08, 0x44, 0xB0, 0x49, 0x67, 0xF5, 0xA5, 0x3E, 0x78, 0xCC, 0x21, 0x34, 0x12, 0x73, 0x2E, + 0xD3, 0xFC, 0x85, 0x2B, 0x10, 0xB9, 0x62, 0xC4, 0x03, 0x44, 0xB3, 0x2C, 0xE5, 0x45, 0xC6, 0xF6, + 0x79, 0xD0, 0xD5, 0xDC, 0x52, 0x62, 0x28, 0xFF, 0xFB, 0x92, 0x64, 0x3C, 0x0F, 0x64, 0xC3, 0x33, + 0xC9, 0x0B, 0xB8, 0x63, 0xE0, 0x2F, 0x03, 0xD9, 0x69, 0x04, 0x08, 0x06, 0x13, 0x40, 0xD3, 0x26, + 0x0E, 0xEF, 0x07, 0x00, 0xB6, 0x0C, 0xA6, 0x68, 0x20, 0x0C, 0x88, 0xA7, 0xBA, 0x68, 0x35, 0x5E, + 0xDE, 0x3B, 0x3D, 0x33, 0x7B, 0xB6, 0xEC, 0xD3, 0x7E, 0x81, 0xC2, 0x77, 0x1F, 0xB1, 0x93, 0xC4, + 0x8A, 0xA6, 0x40, 0x9E, 0x39, 0x29, 0x1C, 0x16, 0x83, 0xFF, 0xFD, 0x60, 0x04, 0x00, 0x00, 0x03, + 0x82, 0xF4, 0x73, 0x83, 0xA3, 0xBE, 0x14, 0xB3, 0xC6, 0x25, 0x5D, 0x4F, 0x05, 0x30, 0x95, 0xE9, + 0x43, 0xC2, 0xCF, 0x48, 0xF5, 0xFD, 0x50, 0xC9, 0xBA, 0x41, 0xDC, 0x5B, 0x0C, 0x50, 0xB1, 0xB7, + 0x20, 0x40, 0xBA, 0xBE, 0x2C, 0x27, 0x6D, 0x15, 0x7F, 0xFD, 0x6B, 0xC8, 0xC1, 0xF2, 0x28, 0xE5, + 0xC5, 0x70, 0xC4, 0xA6, 0x78, 0xD0, 0xD1, 0x28, 0xC7, 0xE3, 0x94, 0xC0, 0xD1, 0x34, 0xCB, 0xC5, + 0xA4, 0xCA, 0xCF, 0x4D, 0x27, 0x58, 0x5B, 0x74, 0x86, 0x20, 0xCD, 0x89, 0x45, 0xAA, 0x8D, 0xCD, + 0x24, 0xD7, 0x92, 0x03, 0x00, 0x41, 0xA1, 0x04, 0x48, 0x20, 0x41, 0x22, 0xFF, 0x0A, 0x80, 0x16, + 0x70, 0xB3, 0x8B, 0x76, 0xBC, 0xAE, 0x6E, 0x59, 0x28, 0x25, 0x6B, 0x7C, 0xE8, 0x33, 0xE4, 0x74, + 0x4E, 0x16, 0x94, 0x3C, 0x30, 0x33, 0x0B, 0xD6, 0xEA, 0x80, 0x8E, 0xF9, 0xFF, 0x25, 0x15, 0xB2, + 0x42, 0xD0, 0x1F, 0x8C, 0x0E, 0x3F, 0xBC, 0xC2, 0x14, 0x56, 0x47, 0xC2, 0x66, 0xDF, 0x6B, 0x02, + 0x15, 0x80, 0x4A, 0xCD, 0x91, 0x29, 0x42, 0xD5, 0xCA, 0x9D, 0x2D, 0x47, 0x6A, 0x8E, 0xED, 0x3C, + 0xBB, 0x1D, 0x43, 0xF1, 0x7C, 0x31, 0x97, 0xDE, 0xF7, 0xF2, 0x07, 0x92, 0x3F, 0x33, 0xD5, 0xDD, + 0xA7, 0xF2, 0x2D, 0x2F, 0x5D, 0x12, 0x06, 0x72, 0xB0, 0xFB, 0x59, 0x0F, 0x26, 0x52, 0xC8, 0xDC, + 0x27, 0x92, 0xB9, 0xFB, 0xE2, 0x84, 0x05, 0x00, 0x1B, 0x54, 0xFE, 0xBC, 0x10, 0x5E, 0x0D, 0x6B, + 0x06, 0x55, 0xFF, 0x56, 0x83, 0xA6, 0x15, 0xCD, 0xD0, 0x61, 0x3F, 0xF7, 0xA2, 0x14, 0x40, 0x4C, + 0x78, 0x12, 0x26, 0x0F, 0x02, 0xF9, 0xF4, 0x49, 0x67, 0x13, 0x78, 0x40, 0xB9, 0xEE, 0x77, 0xFF, + 0x14, 0xDA, 0x00, 0x03, 0x04, 0x0F, 0x30, 0x31, 0x83, 0xFD, 0x93, 0x37, 0x1C, 0xC3, 0x1F, 0x19, + 0x37, 0xEA, 0x33, 0x1E, 0x3A, 0x05, 0x54, 0x1F, 0xED, 0xF2, 0x3C, 0x4D, 0x08, 0x3C, 0x81, 0x52, + 0x46, 0x56, 0x0B, 0x03, 0x8B, 0x06, 0x54, 0x33, 0x1F, 0x99, 0x9E, 0x3F, 0x87, 0xE4, 0x65, 0x1E, + 0x3C, 0x39, 0xB4, 0xF0, 0xA8, 0xA1, 0x7B, 0xC4, 0x96, 0x45, 0x04, 0xAC, 0x79, 0xEF, 0xB8, 0x09, + 0xBE, 0xAF, 0xE1, 0xB3, 0x10, 0x23, 0x08, 0xA4, 0x0C, 0x44, 0x00, 0xB3, 0xC6, 0xA0, 0xC5, 0xC3, + 0x14, 0x08, 0x60, 0xC4, 0x7D, 0x2C, 0x9A, 0xCF, 0xE4, 0x91, 0x6C, 0xB4, 0xC5, 0x1B, 0x11, 0x66, + 0x5A, 0xA0, 0x50, 0xEE, 0x70, 0x5C, 0x74, 0x85, 0x33, 0xFF, 0xFB, 0x92, 0x64, 0x33, 0x8E, 0x45, + 0x50, 0x34, 0x4A, 0x93, 0x7C, 0xC9, 0xA0, 0x2F, 0x08, 0x3A, 0x0A, 0x08, 0x22, 0x7E, 0x94, 0x20, + 0xCB, 0x2E, 0x6E, 0x63, 0x51, 0x00, 0xB1, 0x8E, 0xE8, 0x0C, 0x30, 0x0C, 0xC2, 0xC7, 0x1C, 0x58, + 0xE6, 0xB0, 0xC8, 0x49, 0x03, 0x06, 0xA3, 0x7F, 0x4B, 0x78, 0x92, 0x89, 0x98, 0xE5, 0x59, 0xFD, + 0xC0, 0x0C, 0xDB, 0xF7, 0x00, 0x3A, 0xD7, 0xA0, 0xB6, 0x5B, 0x2A, 0x96, 0x43, 0xD2, 0xA7, 0xEB, + 0xE1, 0xFB, 0x2E, 0x0B, 0xB3, 0x28, 0x92, 0xB8, 0xCD, 0x25, 0x41, 0x53, 0x9C, 0x1C, 0x34, 0x1E, + 0x80, 0xB7, 0xBA, 0xED, 0xA9, 0x76, 0x15, 0x6E, 0x3F, 0xF2, 0xE4, 0xEB, 0xAD, 0x8E, 0xB5, 0xAB, + 0x40, 0x30, 0x04, 0x00, 0x08, 0x74, 0x02, 0x35, 0x1B, 0xF5, 0x41, 0xC3, 0x83, 0x39, 0xAB, 0x7F, + 0x3A, 0x30, 0x03, 0x8C, 0xCA, 0x40, 0xF9, 0xE6, 0x40, 0x71, 0xC6, 0xD9, 0x8E, 0xBE, 0x7F, 0xDF, + 0xFF, 0xEB, 0xF5, 0x5D, 0x7F, 0xFF, 0x9D, 0x4B, 0xA3, 0xF0, 0x31, 0x84, 0x35, 0x05, 0xAC, 0x06, + 0x00, 0x02, 0x0A, 0x18, 0x34, 0x1A, 0x6B, 0x81, 0x11, 0x99, 0xD3, 0x66, 0x1C, 0x02, 0x19, 0x1C, + 0x12, 0x61, 0x80, 0x71, 0xCF, 0xE7, 0x66, 0x20, 0x1E, 0x14, 0x37, 0x03, 0x0C, 0x86, 0x11, 0x15, + 0x05, 0x44, 0xA1, 0x8E, 0x23, 0x34, 0xA6, 0xCC, 0xB0, 0x43, 0x33, 0x18, 0xC8, 0xD3, 0xCD, 0x40, + 0xB8, 0x80, 0xCB, 0xA3, 0x43, 0x10, 0x09, 0xCC, 0x88, 0x1A, 0x32, 0x08, 0xCB, 0xE0, 0xD9, 0x1C, + 0x8E, 0xDB, 0x30, 0xF7, 0x5E, 0x52, 0x08, 0x80, 0x86, 0x41, 0x5F, 0x03, 0x08, 0x34, 0xC0, 0x2B, + 0x4F, 0xFA, 0x3E, 0x10, 0xCC, 0xD2, 0xF7, 0x99, 0x2A, 0x6A, 0x3B, 0x73, 0x56, 0xAB, 0x17, 0x27, + 0xB9, 0x2F, 0x2F, 0x01, 0x23, 0x1C, 0x94, 0x88, 0x2E, 0xE2, 0x98, 0xAB, 0x61, 0xC5, 0x18, 0x35, + 0x08, 0x64, 0x08, 0x41, 0x17, 0x51, 0xE0, 0x56, 0xD8, 0xF2, 0xBD, 0x97, 0xDA, 0xA9, 0xBB, 0x57, + 0x37, 0x67, 0x3A, 0x5A, 0x7A, 0xF2, 0xFC, 0xBB, 0xAA, 0xF4, 0xFD, 0xAB, 0x2B, 0xEF, 0x27, 0x35, + 0x5F, 0xB1, 0xF2, 0xC0, 0x36, 0xA5, 0x54, 0x80, 0x3B, 0x53, 0xDE, 0x74, 0xFF, 0xFB, 0x62, 0xCF, + 0x00, 0x06, 0x14, 0x00, 0x91, 0x21, 0x84, 0x4F, 0x81, 0x07, 0x4C, 0x18, 0xA0, 0x60, 0x62, 0x77, + 0xA6, 0x18, 0x90, 0x90, 0x90, 0xCD, 0x62, 0x35, 0x0E, 0xA6, 0xF3, 0xFE, 0xA3, 0xA0, 0x94, 0xBA, + 0x10, 0x20, 0x4C, 0x26, 0x5F, 0xF4, 0xFF, 0x0D, 0x96, 0xDF, 0xFE, 0xBD, 0x35, 0x30, 0x38, 0x64, + 0xC1, 0x23, 0x91, 0xA7, 0x91, 0x87, 0x86, 0xA1, 0x93, 0x63, 0x08, 0x02, 0xCC, 0x98, 0x39, 0x33, + 0x88, 0x1C, 0xE3, 0xC5, 0xF3, 0x1B, 0x04, 0x80, 0x48, 0x43, 0x0A, 0x05, 0x4C, 0x74, 0x38, 0x31, + 0x10, 0xAC, 0xC1, 0xE0, 0x13, 0x3D, 0x9F, 0x0D, 0x06, 0x20, 0x02, 0x0C, 0xC0, 0xB0, 0x99, 0x8A, + 0x99, 0xC1, 0xA4, 0x58, 0x73, 0x28, 0xEB, 0x09, 0x24, 0x02, 0x44, 0xFF, 0xFB, 0x92, 0x64, 0x1F, + 0x0F, 0x44, 0xB7, 0x33, 0x4C, 0x83, 0x99, 0x7B, 0xE0, 0x30, 0x83, 0xF9, 0xDD, 0x08, 0x43, 0x0A, + 0x11, 0x58, 0xCD, 0x32, 0x0D, 0xE9, 0xE9, 0x00, 0xBA, 0x13, 0xE6, 0x50, 0x83, 0x09, 0xBA, 0x84, + 0x87, 0xD3, 0x34, 0x53, 0x28, 0x04, 0xB9, 0x2B, 0x25, 0x38, 0x19, 0xC8, 0x28, 0xE5, 0xE4, 0x97, + 0x48, 0xF4, 0x84, 0x4E, 0x2A, 0x2F, 0x42, 0xE7, 0xAC, 0xDF, 0xDD, 0x56, 0xD8, 0xB4, 0xEB, 0x44, + 0x89, 0x12, 0x10, 0x1D, 0xA5, 0xAA, 0x8F, 0x22, 0x40, 0x2E, 0xD4, 0x35, 0x51, 0x0C, 0x10, 0x4C, + 0xCC, 0xD2, 0x01, 0xF4, 0x74, 0x18, 0x0E, 0x8B, 0x2E, 0x91, 0x89, 0x35, 0xC3, 0x81, 0x91, 0x05, + 0xCB, 0x77, 0xC2, 0x1A, 0x83, 0xC4, 0x39, 0x97, 0x91, 0x08, 0xD3, 0xAD, 0xE2, 0xB5, 0x2E, 0x72, + 0x8F, 0xE4, 0x61, 0x29, 0x36, 0xFE, 0x18, 0x34, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x78, 0x02, + 0x18, 0x06, 0x02, 0x38, 0xDA, 0x50, 0x43, 0xD9, 0x84, 0x90, 0x5C, 0x13, 0xB0, 0x51, 0x2F, 0xA9, + 0x35, 0xAC, 0x21, 0x95, 0xE0, 0x48, 0xF1, 0x45, 0x56, 0xCA, 0xE8, 0x2D, 0x95, 0x07, 0x58, 0xC6, + 0x24, 0xC0, 0x42, 0x2F, 0x9F, 0xFE, 0xC2, 0xB2, 0xC6, 0x04, 0x4E, 0x5A, 0x71, 0x28, 0x43, 0x33, + 0x4E, 0x30, 0x43, 0xA4, 0x20, 0x33, 0x16, 0xD0, 0x14, 0x49, 0xC9, 0xEA, 0x18, 0xC1, 0x58, 0x2A, + 0xC9, 0x98, 0x38, 0x71, 0xD6, 0x19, 0xC0, 0xA6, 0x50, 0xB8, 0xEA, 0x22, 0x02, 0x46, 0x08, 0x1A, + 0x68, 0x35, 0x61, 0x08, 0xB4, 0x26, 0xB9, 0xEE, 0x52, 0x53, 0x8F, 0x07, 0x80, 0x22, 0x42, 0x33, + 0x0D, 0xD8, 0xDA, 0x24, 0xE4, 0x64, 0x95, 0x80, 0xEC, 0x06, 0x62, 0x28, 0x44, 0x8B, 0x98, 0xC6, + 0x57, 0x21, 0xF1, 0x47, 0x66, 0xCD, 0x59, 0x17, 0x28, 0x60, 0x12, 0x64, 0x31, 0x2C, 0x0A, 0x30, + 0x85, 0x00, 0x5A, 0x15, 0x44, 0x19, 0x08, 0x5F, 0x57, 0xAF, 0x9C, 0x83, 0xE8, 0x5B, 0x03, 0x7C, + 0x76, 0xAE, 0xDB, 0xA2, 0x3F, 0x71, 0x24, 0xAC, 0xC4, 0xC1, 0x3A, 0xF5, 0x93, 0x35, 0xC9, 0xDC, + 0x79, 0x74, 0xC2, 0x41, 0x14, 0x76, 0x27, 0x56, 0xD7, 0x65, 0xD1, 0x6B, 0x2B, 0xA3, 0x85, 0xB9, + 0xCB, 0xF6, 0x7D, 0x00, 0x02, 0x1B, 0x34, 0x02, 0xEB, 0x37, 0xE3, 0x0E, 0x17, 0xF9, 0x45, 0x4B, + 0xE5, 0x1C, 0xA3, 0xDF, 0xFD, 0xF8, 0xAB, 0x11, 0x90, 0xE6, 0xE2, 0x3B, 0xBC, 0x95, 0x1E, 0xEC, + 0x83, 0x69, 0xD5, 0x09, 0x97, 0x66, 0x5A, 0xFD, 0x6E, 0x94, 0xB7, 0xFE, 0xF8, 0x2F, 0x0F, 0xCA, + 0x38, 0x82, 0x00, 0x00, 0x05, 0x02, 0x04, 0x04, 0x9E, 0x8C, 0x01, 0x03, 0x34, 0xB9, 0x48, 0xC6, + 0xED, 0x93, 0x11, 0x93, 0x8C, 0xE4, 0xD9, 0x30, 0xBA, 0x10, 0xCA, 0x82, 0x73, 0x65, 0x8B, 0x43, + 0x02, 0x00, 0xE2, 0x41, 0x74, 0x4C, 0x4A, 0x35, 0x4C, 0x60, 0x35, 0xF0, 0x88, 0x02, 0x40, 0x03, + 0x0E, 0xFD, 0x23, 0x17, 0x65, 0xEA, 0xC0, 0xCB, 0x18, 0x92, 0x98, 0xC9, 0xD0, 0xFF, 0xFB, 0x92, + 0x64, 0x1D, 0x8E, 0x04, 0x9B, 0x33, 0x4C, 0x1B, 0x98, 0x63, 0xE0, 0x32, 0x43, 0x49, 0xDF, 0x00, + 0xC3, 0x18, 0x13, 0xC4, 0xCD, 0x28, 0x4F, 0x73, 0x05, 0x00, 0xBE, 0x21, 0x27, 0xF4, 0x11, 0x0F, + 0x5A, 0xE2, 0x91, 0x70, 0xFA, 0x64, 0xAF, 0xC8, 0x69, 0xEC, 0x5B, 0xC9, 0x52, 0x4C, 0x55, 0xD8, + 0xA1, 0x6C, 0xFD, 0xD4, 0xB9, 0x0B, 0xA2, 0x81, 0x21, 0xE8, 0x7E, 0x96, 0x2A, 0xA5, 0xB6, 0x93, + 0xAA, 0xBC, 0xCA, 0x02, 0x8B, 0x70, 0xA8, 0xC2, 0x88, 0x53, 0x77, 0xAC, 0x80, 0x93, 0xD0, 0xD3, + 0xCA, 0xF0, 0xC5, 0x9F, 0xE0, 0xB4, 0x08, 0xD4, 0x69, 0x26, 0xB0, 0x4F, 0x3D, 0x25, 0x09, 0x63, + 0xEE, 0xF6, 0x17, 0x6D, 0x25, 0x72, 0x01, 0xD1, 0xEA, 0x19, 0x24, 0x8A, 0xF2, 0xA7, 0x03, 0x2E, + 0xFA, 0xCC, 0x9A, 0xDF, 0xFF, 0x7F, 0x20, 0xED, 0x73, 0x00, 0x08, 0xA0, 0x12, 0x00, 0x00, 0x00, + 0x00, 0x1E, 0x04, 0xE5, 0x6F, 0xEC, 0x88, 0xA5, 0xE7, 0xB8, 0xA8, 0x44, 0xD4, 0xFC, 0xC9, 0x72, + 0xE3, 0xCE, 0x42, 0x7B, 0x33, 0x3E, 0xBC, 0x41, 0x61, 0x44, 0x81, 0x4D, 0x8A, 0x82, 0x46, 0xD4, + 0x7D, 0xAA, 0x32, 0xDE, 0x25, 0x42, 0x6A, 0xEE, 0xFF, 0xFF, 0xA3, 0x58, 0x60, 0x30, 0x03, 0x06, + 0x09, 0xE1, 0x8A, 0x69, 0x5A, 0x14, 0x06, 0x09, 0x01, 0xCE, 0x64, 0x88, 0x25, 0x86, 0x1A, 0x60, + 0x0E, 0x16, 0x1D, 0x99, 0xB8, 0x1A, 0x70, 0x45, 0xB9, 0xE4, 0xC7, 0x46, 0x01, 0x1B, 0x97, 0x70, + 0xC4, 0x61, 0xF3, 0x22, 0xAC, 0x4C, 0x42, 0x0D, 0x37, 0x69, 0x04, 0x10, 0x03, 0x0E, 0x0F, 0x0B, + 0x6D, 0x94, 0xB1, 0x56, 0xFA, 0x1C, 0x8B, 0x27, 0x62, 0x80, 0x24, 0xBA, 0xA9, 0x09, 0x3D, 0xC7, + 0x38, 0x15, 0xAF, 0xB6, 0x24, 0x86, 0x47, 0x18, 0x48, 0x72, 0xC0, 0x3E, 0x0C, 0xA0, 0xC0, 0x59, + 0xD5, 0xEB, 0xB0, 0xC2, 0x6B, 0x51, 0xA7, 0x13, 0x60, 0x0E, 0x88, 0x41, 0x84, 0x96, 0x95, 0xB1, + 0xD4, 0x5E, 0x55, 0x24, 0x3A, 0xAA, 0x54, 0x7C, 0x4E, 0x35, 0x8C, 0x95, 0x89, 0xF7, 0x19, 0x7E, + 0x63, 0x5A, 0xA3, 0x5C, 0x75, 0xA8, 0xE3, 0x2F, 0xED, 0x78, 0xCC, 0xE5, 0x32, 0xAF, 0x96, 0xE5, + 0xDC, 0x77, 0x4B, 0x8E, 0x35, 0x60, 0x86, 0x9F, 0x84, 0xAA, 0xE4, 0x6A, 0x7A, 0x9B, 0x2C, 0xB2, + 0xFF, 0xB9, 0x0D, 0x4F, 0x7F, 0xA1, 0xDE, 0x45, 0x36, 0xA8, 0x81, 0x01, 0x80, 0x90, 0x00, 0x05, + 0xBA, 0x03, 0xF9, 0x0B, 0x26, 0xFC, 0xA4, 0x51, 0xBB, 0xA0, 0x96, 0x5D, 0xDD, 0xF8, 0x66, 0x7D, + 0xF5, 0x26, 0x9C, 0xDF, 0xFA, 0xFD, 0xB9, 0x5C, 0x08, 0x53, 0xBB, 0x4A, 0x6F, 0x9B, 0xFF, 0xFF, + 0x9D, 0xE6, 0x79, 0x51, 0x74, 0x72, 0x12, 0x01, 0x3A, 0xAA, 0x00, 0x0F, 0x03, 0x0A, 0x45, 0x43, + 0x19, 0x94, 0xB3, 0xFB, 0x89, 0x23, 0x15, 0x87, 0xB3, 0x67, 0xD2, 0x73, 0x21, 0xC2, 0x23, 0x0D, + 0xCC, 0x73, 0x75, 0xD1, 0x53, 0x2A, 0x07, 0x33, 0x8D, 0x8D, 0xC4, 0xB5, 0x30, 0xE4, 0xCF, 0xFF, + 0xFB, 0x92, 0x64, 0x12, 0x8C, 0x44, 0xAD, 0x2C, 0x49, 0x93, 0xB8, 0x6B, 0xE0, 0x31, 0x27, 0x99, + 0x93, 0x14, 0x22, 0xBA, 0x11, 0x34, 0xD1, 0x2A, 0x4E, 0xE0, 0xCF, 0x80, 0xC6, 0x24, 0x27, 0x28, + 0x70, 0x89, 0xF8, 0x32, 0x10, 0x05, 0x30, 0x04, 0x37, 0x36, 0xAC, 0x13, 0x31, 0x74, 0x90, 0x28, + 0x11, 0xCC, 0x1B, 0x0D, 0x50, 0x79, 0xF5, 0x64, 0xCB, 0xC0, 0x2C, 0xC0, 0x83, 0x48, 0x21, 0x85, + 0xF6, 0x8A, 0x4F, 0x1A, 0x74, 0x8E, 0xA0, 0x48, 0xCC, 0xC1, 0x0D, 0x06, 0x4C, 0x84, 0xF0, 0x52, + 0x0F, 0x42, 0x97, 0x17, 0x51, 0x1E, 0xD8, 0x3E, 0x54, 0xAA, 0x03, 0x1D, 0x5F, 0x93, 0x48, 0x22, + 0x02, 0xB4, 0xD4, 0x91, 0x23, 0xB9, 0x2B, 0x03, 0x0E, 0x84, 0x68, 0xA2, 0x69, 0x58, 0x5F, 0x64, + 0xF8, 0x65, 0x6B, 0x1A, 0x3B, 0x3B, 0x3B, 0x7A, 0x0D, 0x0B, 0xE3, 0xA2, 0x8A, 0xD2, 0xA8, 0xBE, + 0x0A, 0xAF, 0xF5, 0x95, 0x03, 0x98, 0x2C, 0x77, 0xA5, 0x84, 0x93, 0x59, 0xDA, 0x8C, 0x6E, 0x35, + 0xD6, 0xCC, 0xD0, 0xA0, 0x00, 0x07, 0xB0, 0x0D, 0xFE, 0x02, 0x0E, 0xFD, 0x87, 0x64, 0x52, 0xB3, + 0x14, 0xE9, 0x32, 0xCE, 0x76, 0x17, 0x8E, 0xFC, 0xA6, 0x76, 0x38, 0xB8, 0x88, 0x91, 0x3F, 0xFF, + 0x35, 0xFE, 0x29, 0xF5, 0xF8, 0x38, 0xCD, 0x09, 0x6C, 0x8F, 0x11, 0x8D, 0x08, 0x53, 0x30, 0x86, + 0x19, 0x7B, 0x1B, 0x40, 0x1C, 0x02, 0xAC, 0x04, 0x60, 0x99, 0x86, 0x8C, 0x81, 0xF1, 0xC2, 0x19, + 0x91, 0x07, 0x01, 0x8E, 0x40, 0x19, 0x88, 0xC4, 0x21, 0x83, 0x25, 0xE8, 0x3A, 0x7B, 0x28, 0x23, + 0x8C, 0x79, 0x46, 0xC7, 0x01, 0x90, 0x00, 0x0E, 0x62, 0x98, 0x28, 0x20, 0x0B, 0xCC, 0xE2, 0x2F, + 0x80, 0x49, 0x62, 0x68, 0x8E, 0x06, 0x63, 0x4C, 0x56, 0x96, 0x50, 0xE8, 0x3A, 0x0C, 0xB5, 0x7A, + 0xD1, 0x43, 0x4E, 0xB2, 0xB7, 0x25, 0x73, 0x96, 0xAB, 0xA3, 0x09, 0x0A, 0x8D, 0xAD, 0x79, 0x80, + 0x08, 0xD0, 0x2D, 0x34, 0x6E, 0x51, 0xE8, 0x0B, 0x6E, 0xB4, 0x39, 0x72, 0x92, 0x00, 0x38, 0x09, + 0x91, 0x19, 0x4B, 0x15, 0x08, 0x02, 0xB9, 0x4A, 0x25, 0x2B, 0x4E, 0x36, 0x4B, 0x17, 0x7D, 0x1D, + 0xB7, 0x76, 0x5B, 0x22, 0xBF, 0xBC, 0x25, 0x51, 0xE1, 0x6F, 0xCD, 0x85, 0x33, 0xF7, 0x6C, 0x9E, + 0x70, 0x56, 0xF8, 0xCF, 0xFF, 0x72, 0x77, 0x11, 0xC9, 0x93, 0xFF, 0xFE, 0x2E, 0xDD, 0xF1, 0x40, + 0x08, 0x16, 0x7E, 0x01, 0x76, 0x3C, 0xFA, 0xBE, 0x20, 0x6D, 0xA8, 0x67, 0x68, 0x24, 0xB2, 0x27, + 0x71, 0x00, 0xC8, 0x99, 0x8B, 0xF3, 0x55, 0x1B, 0x22, 0xE4, 0xFF, 0x09, 0x7E, 0xEF, 0xFF, 0xDF, + 0xF7, 0x3A, 0xE4, 0x1D, 0xA7, 0x72, 0x39, 0x48, 0xDC, 0x9F, 0x5F, 0xFD, 0x96, 0x7E, 0x90, 0x4F, + 0x02, 0x0C, 0x18, 0x0B, 0x4C, 0x6B, 0x59, 0x8F, 0x99, 0x8E, 0xCC, 0x63, 0x22, 0x81, 0xA9, 0x99, + 0x87, 0xC0, 0x19, 0x83, 0x60, 0xC1, 0x86, 0x49, 0x11, 0x92, 0x03, 0xD1, 0xA0, 0x85, 0x70, 0xC0, + 0x30, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8E, 0x04, 0x5F, 0x34, 0xCA, 0x8B, 0xB8, 0x3B, 0xE4, 0x33, + 0x27, 0x0A, 0x6D, 0x0C, 0x22, 0x1C, 0x91, 0xF4, 0xD3, 0x2C, 0x4E, 0xEF, 0x03, 0x50, 0xC9, 0x04, + 0xE9, 0x28, 0x60, 0x89, 0x02, 0x61, 0xC0, 0xB2, 0x62, 0x28, 0xF4, 0x61, 0x39, 0x82, 0x63, 0x49, + 0x0A, 0x62, 0x80, 0x82, 0xF2, 0x8B, 0x01, 0x04, 0x50, 0x67, 0x6E, 0x9A, 0x3D, 0xB7, 0x45, 0x34, + 0x81, 0x25, 0x4D, 0x32, 0x85, 0x5F, 0xA7, 0xCA, 0xB0, 0xA8, 0xAA, 0xF9, 0x4E, 0xB2, 0x41, 0x87, + 0x09, 0x07, 0x59, 0x31, 0x01, 0x95, 0xF2, 0x82, 0x32, 0x98, 0x2D, 0x23, 0xF9, 0xA7, 0x81, 0x2A, + 0x15, 0x55, 0x4C, 0xC4, 0x46, 0x5A, 0x42, 0x36, 0x00, 0xD6, 0x04, 0x10, 0x8D, 0xC9, 0xF7, 0x0A, + 0x58, 0x47, 0x4D, 0xB7, 0x67, 0x53, 0xEF, 0x75, 0x3F, 0x64, 0x82, 0xD2, 0x63, 0xF6, 0x1C, 0xE7, + 0x9C, 0xDC, 0xFF, 0xC7, 0x4A, 0x11, 0xF5, 0x14, 0x17, 0x12, 0x0B, 0x89, 0xC1, 0x30, 0x00, 0x2C, + 0x80, 0x45, 0x01, 0x13, 0x4C, 0x2B, 0x36, 0x01, 0xCD, 0x45, 0x9C, 0x6E, 0x53, 0x8E, 0xD4, 0x65, + 0x67, 0xCC, 0x11, 0x74, 0xDF, 0x70, 0xC6, 0x62, 0x34, 0x8D, 0xFF, 0x77, 0x3B, 0xA3, 0x7F, 0x71, + 0x79, 0x3E, 0x6F, 0x4F, 0xEF, 0xF5, 0xB9, 0x58, 0xF2, 0x74, 0x47, 0x51, 0xF3, 0x8F, 0xF5, 0x39, + 0x4A, 0x7D, 0x09, 0x08, 0x08, 0x00, 0xE3, 0x10, 0x56, 0xD3, 0xA1, 0xDC, 0xA3, 0x26, 0xC9, 0x13, + 0xE2, 0x7E, 0x35, 0x83, 0x23, 0x0B, 0x66, 0x36, 0x68, 0x93, 0x5B, 0x36, 0x30, 0xB1, 0x42, 0x41, + 0xF4, 0xFA, 0x37, 0x85, 0x03, 0xAE, 0x80, 0x30, 0xA4, 0xF2, 0x37, 0x27, 0x10, 0x64, 0x69, 0x66, + 0x48, 0xDD, 0xF6, 0xE3, 0x16, 0x22, 0x04, 0x45, 0xF7, 0x8B, 0x33, 0x5B, 0x8A, 0x5E, 0x84, 0xE2, + 0xD0, 0x25, 0xFB, 0xFF, 0x48, 0x9F, 0xE2, 0x23, 0x33, 0x34, 0x5E, 0x41, 0x74, 0xAB, 0xCB, 0x8B, + 0xF2, 0x5C, 0xE5, 0xB1, 0xA4, 0xB8, 0x52, 0xF6, 0xDC, 0x48, 0xCD, 0xC1, 0x9B, 0xB0, 0xD4, 0x97, + 0x4C, 0x24, 0x4D, 0x86, 0x88, 0x40, 0x91, 0x6C, 0x1A, 0x36, 0xFF, 0x3D, 0x10, 0x9C, 0xDF, 0xA9, + 0xDB, 0x13, 0x5F, 0x6E, 0x9F, 0xFF, 0xF9, 0xDE, 0x7F, 0xDC, 0xB1, 0xFF, 0xFF, 0xBC, 0xA5, 0x32, + 0x38, 0xE5, 0x8F, 0xFF, 0xD4, 0xCD, 0x15, 0x14, 0xBD, 0x87, 0xC4, 0xA5, 0x7C, 0xFF, 0xA9, 0x94, + 0x57, 0xBC, 0x64, 0x06, 0x07, 0x20, 0x82, 0xE4, 0xC0, 0x04, 0x24, 0x72, 0x66, 0x4D, 0x7A, 0xBA, + 0x83, 0x62, 0xD0, 0x52, 0x41, 0x11, 0x30, 0x2B, 0x53, 0x16, 0xBE, 0x1C, 0x96, 0xAB, 0xDD, 0x99, + 0xB6, 0x8B, 0x4A, 0xF2, 0xA6, 0xE5, 0x44, 0xA8, 0x6F, 0x57, 0xAC, 0x40, 0xB1, 0x33, 0xC5, 0x47, + 0x84, 0xE1, 0xF2, 0x0D, 0x3A, 0x00, 0x02, 0x03, 0x02, 0xC0, 0x43, 0x0F, 0x8C, 0x73, 0xA3, 0x07, + 0xC3, 0x1B, 0x89, 0xF0, 0x1D, 0x71, 0x99, 0x0F, 0x9A, 0xD9, 0xB9, 0xA1, 0xB9, 0x18, 0x98, 0xE9, + 0xA0, 0xDE, 0x1A, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0E, 0x04, 0x67, 0x34, 0x4C, 0x13, 0xBB, 0xD0, + 0xA4, 0x33, 0x48, 0xBA, 0x5D, 0x08, 0xC5, 0x80, 0x90, 0xEC, 0xD1, 0x36, 0x4E, 0x64, 0xED, 0xD0, + 0xCD, 0x07, 0xA8, 0x74, 0x11, 0x98, 0x3A, 0x70, 0x21, 0x40, 0xA7, 0xAD, 0x20, 0xC1, 0xF3, 0x38, + 0x54, 0xD6, 0x14, 0x30, 0xC3, 0x94, 0x15, 0xCC, 0x86, 0xD7, 0x1C, 0xB1, 0x25, 0xD7, 0xEC, 0x9D, + 0xE0, 0x94, 0x47, 0xE4, 0x30, 0xE3, 0xB8, 0x54, 0x1D, 0x54, 0xB7, 0xAC, 0xA4, 0xBB, 0xED, 0x1A, + 0x24, 0xBF, 0x5F, 0x25, 0xF5, 0x18, 0xA8, 0xFD, 0xFA, 0xF0, 0x51, 0xC5, 0xF0, 0x88, 0xA3, 0xA5, + 0xDA, 0xD9, 0x7E, 0xD1, 0x18, 0x58, 0x1B, 0xC4, 0x17, 0x0C, 0xA6, 0xED, 0xA4, 0x4A, 0x5F, 0x00, + 0x5E, 0x74, 0x25, 0x58, 0xF7, 0x9D, 0xDD, 0x9F, 0xA5, 0xCB, 0xFF, 0xE2, 0x70, 0x3D, 0xE8, 0xDF, + 0x68, 0x31, 0xFF, 0xFF, 0xA9, 0x44, 0xF3, 0x53, 0x43, 0x94, 0x5F, 0xFF, 0xF2, 0xFA, 0xAF, 0x4C, + 0x37, 0x66, 0x6E, 0x2C, 0xEF, 0xD5, 0x08, 0x00, 0x80, 0xE0, 0x28, 0x0A, 0x9E, 0x00, 0x58, 0xBA, + 0xB3, 0x95, 0x9E, 0x86, 0xAA, 0xBE, 0xF8, 0x71, 0x6B, 0xAC, 0xF6, 0xA3, 0x2A, 0xCB, 0xBD, 0x8B, + 0xE7, 0xFF, 0xF6, 0xFF, 0x97, 0xA0, 0xD0, 0x0C, 0x1D, 0x84, 0x3F, 0xE7, 0xFF, 0xDF, 0xFF, 0xFE, + 0xD2, 0x2D, 0xC6, 0x0F, 0xED, 0x3E, 0xC6, 0x12, 0xCA, 0x06, 0x02, 0x80, 0xB0, 0xA9, 0xE8, 0xE1, + 0x4D, 0xF1, 0xA3, 0x01, 0x94, 0xDC, 0x27, 0x1D, 0x3D, 0xA2, 0x90, 0x29, 0xF8, 0x02, 0x07, 0x18, + 0x4C, 0x56, 0x64, 0x30, 0x82, 0x10, 0x19, 0x80, 0x8C, 0x64, 0x24, 0x68, 0x04, 0x16, 0x62, 0x3E, + 0x74, 0x8A, 0xAD, 0x89, 0xD7, 0x0B, 0x5A, 0xAB, 0xAD, 0x63, 0x96, 0x81, 0x3A, 0x1B, 0x8C, 0x06, + 0xD4, 0x67, 0x01, 0x02, 0x15, 0x11, 0x36, 0xCB, 0x19, 0x04, 0x15, 0x18, 0x70, 0x73, 0x2B, 0xA1, + 0xCF, 0x8B, 0x58, 0x9F, 0x94, 0x48, 0x65, 0x97, 0xDC, 0xA3, 0x10, 0x27, 0x90, 0xC8, 0x49, 0x04, + 0x10, 0x23, 0x32, 0x64, 0x33, 0xD2, 0x38, 0xF5, 0xE7, 0xF2, 0x77, 0x3A, 0x99, 0xB9, 0x6C, 0x5E, + 0xFF, 0xFF, 0xFC, 0x1E, 0x06, 0x0C, 0x1F, 0x24, 0xAF, 0x99, 0x11, 0xC6, 0xE0, 0xF0, 0x02, 0xC2, + 0xA4, 0x51, 0x95, 0xC0, 0xF0, 0x26, 0x0F, 0x0F, 0x22, 0x03, 0x8F, 0x7F, 0xF3, 0x0A, 0xBF, 0xBE, + 0x90, 0x80, 0x10, 0x02, 0x80, 0x00, 0x92, 0x68, 0x16, 0x97, 0x01, 0x9B, 0x6C, 0xFE, 0x14, 0x4F, + 0x7E, 0x57, 0x40, 0x72, 0xB7, 0xB2, 0xCA, 0x4F, 0x56, 0x64, 0xAA, 0x43, 0x71, 0x64, 0x08, 0x4D, + 0x8D, 0x36, 0x21, 0x67, 0xD9, 0x90, 0xA4, 0xA0, 0x0B, 0x5C, 0xB7, 0xF9, 0x6A, 0x84, 0xAF, 0xB4, + 0x46, 0x34, 0x03, 0xBA, 0x90, 0x00, 0x41, 0x13, 0x60, 0xC6, 0xC2, 0x00, 0x08, 0xC2, 0x83, 0x84, + 0xCC, 0x70, 0x74, 0xC1, 0x01, 0x08, 0xE1, 0x61, 0x14, 0xC6, 0x70, 0x10, 0x42, 0x26, 0x98, 0xDE, + 0x08, 0x81, 0x42, 0xA0, 0x28, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8F, 0x04, 0x7E, 0x34, 0x4E, 0x83, + 0xBA, 0x7B, 0x60, 0x2E, 0x85, 0x99, 0x85, 0x1D, 0x02, 0x96, 0xD2, 0x10, 0xD3, 0x3C, 0x0E, 0xE5, + 0xEF, 0x40, 0xC1, 0x8B, 0x27, 0xA8, 0x84, 0x99, 0xCA, 0x2A, 0x62, 0x08, 0x84, 0x63, 0x8B, 0x34, + 0x62, 0x66, 0x48, 0x8E, 0xAB, 0x30, 0x31, 0x46, 0xD1, 0xC0, 0x76, 0x46, 0x87, 0x31, 0xC5, 0xA7, + 0x04, 0x3C, 0x49, 0x40, 0xDD, 0x14, 0xCD, 0x89, 0x90, 0x8E, 0x36, 0xA8, 0xD1, 0x9C, 0x54, 0xC2, + 0x10, 0x16, 0xB9, 0xBC, 0xA3, 0x82, 0x1B, 0x47, 0x05, 0xA4, 0x41, 0x8E, 0xDC, 0x4D, 0x54, 0x44, + 0x02, 0x8C, 0x29, 0xA3, 0x00, 0x74, 0x98, 0xD5, 0xC2, 0xD6, 0x35, 0x86, 0x70, 0xDC, 0x75, 0x27, + 0x05, 0x9C, 0xFF, 0x34, 0xDB, 0xC2, 0x0C, 0x03, 0x83, 0x84, 0x4F, 0xFF, 0xFF, 0xFF, 0xD8, 0xB0, + 0xB2, 0x87, 0x3C, 0xC4, 0x09, 0x7E, 0x0B, 0xBA, 0x7F, 0x48, 0x79, 0xD0, 0x7E, 0xCF, 0x24, 0xBD, + 0x81, 0xC1, 0x3E, 0xAE, 0xD8, 0xC2, 0x7C, 0xF1, 0x84, 0x04, 0x1B, 0x6F, 0x31, 0x88, 0x15, 0x73, + 0x3A, 0x78, 0x5C, 0x02, 0xC9, 0x8A, 0x01, 0xC2, 0xA7, 0x26, 0xED, 0xF1, 0xE9, 0x47, 0xB8, 0x08, + 0x06, 0x87, 0xDA, 0x4A, 0xF2, 0xB4, 0xD0, 0x14, 0x4C, 0xC2, 0x8D, 0xFF, 0xFE, 0x95, 0xD0, 0xF5, + 0x76, 0x06, 0x37, 0x9F, 0x9B, 0xC3, 0xE1, 0x82, 0x00, 0xBC, 0xCF, 0x80, 0x9C, 0xC1, 0x90, 0x6C, + 0x94, 0x9F, 0x32, 0x94, 0x0A, 0x11, 0x88, 0x86, 0xB8, 0xD3, 0x42, 0x46, 0xE1, 0x83, 0x40, 0x81, + 0x81, 0x61, 0x91, 0x08, 0x14, 0x60, 0xF8, 0x90, 0x15, 0x00, 0x4C, 0x4A, 0x43, 0x8C, 0xB2, 0x06, + 0x41, 0x80, 0x31, 0x8A, 0x41, 0xB0, 0x18, 0x19, 0xD8, 0x6A, 0x0F, 0x31, 0x0D, 0x95, 0xA8, 0x7A, + 0x91, 0x78, 0x14, 0xE7, 0x4D, 0x1C, 0x69, 0x10, 0xA1, 0x86, 0x71, 0x81, 0x1B, 0x00, 0x00, 0x43, + 0x9A, 0xEB, 0x4A, 0x3D, 0xB3, 0xC6, 0x52, 0xF4, 0xB4, 0xB9, 0x32, 0x76, 0xC3, 0x31, 0x54, 0xBF, + 0x28, 0x14, 0xCD, 0x14, 0xEF, 0x48, 0x80, 0x12, 0xEF, 0xA6, 0x2B, 0xFC, 0x65, 0x40, 0x30, 0xC4, + 0xF5, 0x80, 0xB6, 0x4C, 0x32, 0x47, 0xD8, 0xB6, 0x10, 0xCD, 0xFF, 0xFF, 0xFF, 0xF5, 0xDA, 0x99, + 0xB5, 0x65, 0x77, 0x6D, 0xBE, 0xF7, 0x3D, 0x5C, 0xD2, 0xAA, 0xE7, 0x03, 0x72, 0x7E, 0xCD, 0xD7, + 0x58, 0xB3, 0x9E, 0x1C, 0x99, 0x1F, 0xD0, 0xF4, 0x09, 0x40, 0x05, 0x60, 0x80, 0x24, 0xF5, 0xF5, + 0xDA, 0x47, 0x84, 0x0C, 0xF5, 0xB5, 0x7C, 0x8C, 0xDB, 0x30, 0x1A, 0x13, 0x0A, 0x77, 0x3F, 0xA1, + 0x9A, 0xF6, 0x17, 0xB3, 0x75, 0xBC, 0x1D, 0x56, 0xB3, 0x2C, 0x20, 0x10, 0x2E, 0x8F, 0x2E, 0x2B, + 0x45, 0x61, 0xA6, 0x83, 0x33, 0xA1, 0x27, 0xD5, 0x8B, 0xA6, 0x01, 0x9D, 0x21, 0xF1, 0x82, 0x01, + 0x79, 0x80, 0xA3, 0xE9, 0x99, 0x20, 0x49, 0x70, 0x0D, 0x28, 0xCA, 0xCC, 0x1C, 0x06, 0x4A, 0x81, + 0xF9, 0x94, 0xA0, 0xD8, 0xC0, 0x0C, 0x61, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x87, 0x24, 0x7B, 0x34, + 0xCE, 0x83, 0xBA, 0x7B, 0xD0, 0x32, 0x66, 0x69, 0xCC, 0x15, 0x25, 0x76, 0x51, 0x28, 0xD3, 0x3B, + 0x0E, 0xE9, 0x2F, 0x90, 0xC3, 0x9A, 0x26, 0xD0, 0x24, 0x96, 0x10, 0xC0, 0x76, 0x9E, 0xC6, 0x15, + 0xAF, 0x40, 0x62, 0x94, 0x78, 0x06, 0x33, 0x2C, 0x61, 0x0E, 0x51, 0x01, 0x17, 0xC2, 0x54, 0x60, + 0x43, 0x45, 0xC4, 0x44, 0xD8, 0xF3, 0x32, 0x22, 0x01, 0x81, 0x08, 0xB5, 0x2D, 0x02, 0x8A, 0x1E, + 0xAC, 0xA1, 0xA2, 0x2B, 0xC6, 0x08, 0x04, 0x25, 0x3C, 0x64, 0x4F, 0x13, 0x95, 0x1D, 0xB1, 0x93, + 0x61, 0x90, 0xCB, 0xD9, 0x4C, 0x32, 0x61, 0x1B, 0x84, 0x43, 0x11, 0x03, 0x6C, 0xD0, 0x32, 0xD0, + 0x9E, 0x00, 0x90, 0x23, 0x88, 0x84, 0xA1, 0xA4, 0x85, 0x27, 0x00, 0x05, 0xC1, 0xB6, 0x7F, 0xFF, + 0xFA, 0x44, 0x52, 0xBC, 0x57, 0x2A, 0xE6, 0xAE, 0x19, 0x7F, 0x71, 0x51, 0xB3, 0xA0, 0x15, 0x4C, + 0x9A, 0xCB, 0x87, 0x85, 0x59, 0x27, 0x33, 0xC6, 0x4A, 0xDA, 0xE3, 0x40, 0x02, 0x00, 0x80, 0x00, + 0x00, 0xC0, 0x0B, 0x16, 0xFA, 0x46, 0xA0, 0x80, 0x6F, 0x6F, 0x19, 0x75, 0x10, 0x94, 0x0A, 0xD1, + 0x92, 0x17, 0xA0, 0x40, 0x6F, 0xD0, 0x19, 0x15, 0x02, 0xA1, 0xD1, 0x8F, 0x56, 0x68, 0xAA, 0x80, + 0x8B, 0xFF, 0xAF, 0x93, 0xFF, 0x8E, 0xEF, 0xFB, 0xA5, 0x7F, 0xBC, 0x3E, 0x24, 0x2E, 0x00, 0x26, + 0x10, 0xAC, 0xCD, 0xC1, 0xE4, 0xC0, 0x20, 0x98, 0x0A, 0x23, 0x82, 0x99, 0xF3, 0x02, 0xC3, 0x03, + 0x47, 0xE5, 0x60, 0x20, 0x16, 0x60, 0xE8, 0x60, 0x4C, 0x43, 0x2A, 0xB1, 0x88, 0x63, 0x22, 0xAC, + 0x1C, 0x4E, 0x0C, 0xA6, 0x0A, 0x04, 0x80, 0x53, 0x1F, 0x07, 0x61, 0x40, 0xAA, 0x50, 0x50, 0x56, + 0x1E, 0x08, 0x13, 0x0C, 0x22, 0x08, 0xF0, 0x3C, 0xD1, 0xFE, 0x56, 0x54, 0x0E, 0xE1, 0x32, 0x91, + 0x90, 0x8F, 0xC8, 0xAC, 0xE3, 0x6C, 0x0D, 0xF8, 0x08, 0x0D, 0x26, 0x8F, 0x4F, 0x50, 0x46, 0xAA, + 0x5C, 0xC2, 0xED, 0x98, 0x7D, 0x4D, 0x80, 0xE3, 0xD9, 0x28, 0x50, 0x2A, 0xFE, 0x66, 0x4C, 0x43, + 0x8C, 0x4E, 0x84, 0x64, 0x04, 0xA6, 0x85, 0x15, 0xA2, 0xEC, 0xC4, 0x68, 0x3F, 0x7F, 0xFF, 0xFE, + 0x92, 0xF6, 0x65, 0xE2, 0x96, 0xEC, 0xDE, 0xDC, 0xD1, 0x00, 0x21, 0x08, 0x89, 0x60, 0xAB, 0xAF, + 0xF8, 0xB8, 0xFE, 0x0B, 0x52, 0xC4, 0x11, 0x2C, 0x60, 0x03, 0x00, 0x00, 0xB3, 0x74, 0x3C, 0xA5, + 0x43, 0x76, 0xF3, 0x49, 0xA4, 0x08, 0x53, 0x59, 0xED, 0x09, 0xEB, 0xD2, 0x24, 0xDA, 0x7F, 0xF7, + 0x61, 0x7F, 0x8D, 0x00, 0xC4, 0x71, 0x41, 0x70, 0xE0, 0xD6, 0x38, 0x73, 0xFE, 0xBB, 0xBA, 0xB7, + 0xCC, 0x64, 0x33, 0x7C, 0xA4, 0xA1, 0x84, 0xCC, 0x80, 0x00, 0x04, 0x32, 0x87, 0x73, 0x43, 0x48, + 0x21, 0x18, 0xA8, 0x60, 0x80, 0x8A, 0x24, 0xD7, 0x02, 0x04, 0xD3, 0x1B, 0x2D, 0x34, 0x8B, 0x00, + 0x02, 0x26, 0x87, 0x80, 0x64, 0xA0, 0x59, 0x84, 0xC4, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x87, 0x14, + 0x8D, 0x34, 0xCE, 0x2B, 0xBA, 0x7B, 0xD0, 0x2E, 0x45, 0xC9, 0xDD, 0x00, 0xC5, 0x66, 0x12, 0x2C, + 0xD3, 0x36, 0x0E, 0xE9, 0xEF, 0x40, 0xBC, 0x10, 0xA6, 0xF0, 0x13, 0x15, 0xD0, 0xB8, 0x14, 0x03, + 0x30, 0x1D, 0x7E, 0x32, 0xE0, 0x15, 0x48, 0x83, 0x1A, 0x45, 0x11, 0x18, 0x44, 0x5E, 0x1E, 0x08, + 0xEB, 0x18, 0x71, 0x0C, 0x51, 0x3B, 0xC3, 0x83, 0x44, 0xCC, 0x00, 0xA9, 0x40, 0xA0, 0xB1, 0xA2, + 0x92, 0xD1, 0x54, 0xAF, 0x09, 0x85, 0x70, 0x78, 0xCA, 0xB8, 0x25, 0x40, 0xB0, 0x75, 0x03, 0xDB, + 0x3A, 0xC6, 0x1E, 0xCD, 0xFD, 0xC9, 0xB4, 0xF8, 0x1C, 0x06, 0x13, 0x49, 0x83, 0x15, 0x11, 0x44, + 0xA5, 0x41, 0x01, 0x7E, 0x4D, 0x19, 0xD0, 0xD4, 0x4A, 0x8C, 0x17, 0x6A, 0xD0, 0xFD, 0x06, 0x36, + 0xB1, 0xFF, 0xFF, 0xED, 0xCF, 0x76, 0xDC, 0xB2, 0x65, 0x31, 0xBF, 0x13, 0x0C, 0x0E, 0x10, 0x61, + 0x26, 0xB2, 0xF3, 0x7F, 0xA4, 0x95, 0x6A, 0x02, 0xC6, 0xB6, 0x46, 0x89, 0x63, 0x80, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x28, 0x00, 0x06, 0x8F, 0xC5, 0x8A, 0x22, 0x48, 0x61, 0xE6, 0xC8, 0x9C, 0x05, + 0x24, 0xDF, 0x27, 0xDB, 0xA0, 0xEF, 0x8A, 0x8A, 0x19, 0x54, 0x70, 0xB1, 0xC4, 0x67, 0x08, 0x2F, + 0xF4, 0x6A, 0x3A, 0x9A, 0xDA, 0xDE, 0x56, 0x16, 0xD6, 0x74, 0x02, 0x2D, 0x2A, 0x1C, 0x01, 0xCD, + 0x18, 0x22, 0x4C, 0x03, 0x0A, 0xCC, 0x08, 0x19, 0x4C, 0xDD, 0x00, 0x0C, 0x0B, 0x03, 0x8C, 0x34, + 0xB9, 0x8C, 0x65, 0x00, 0x8C, 0x0D, 0x1C, 0xC2, 0x18, 0x75, 0x0B, 0x30, 0xA0, 0xD2, 0x04, 0x01, + 0xE6, 0x0D, 0xB3, 0x46, 0x95, 0x8A, 0xE0, 0x10, 0x48, 0x14, 0x62, 0x9A, 0xE1, 0x29, 0x28, 0x5E, + 0x76, 0x9C, 0x14, 0x56, 0xEE, 0xA0, 0x58, 0x18, 0xC6, 0x8C, 0x48, 0x25, 0x08, 0x56, 0xC1, 0xE9, + 0xB3, 0x71, 0x72, 0x21, 0x65, 0x50, 0x26, 0x55, 0xF2, 0x56, 0x97, 0xB1, 0xE5, 0xA8, 0x17, 0x03, + 0x7D, 0xC2, 0x56, 0x8E, 0xFD, 0xCE, 0x22, 0x83, 0xF4, 0x79, 0x92, 0x21, 0x68, 0x04, 0x91, 0x32, + 0xC7, 0xD8, 0x23, 0xD6, 0x11, 0x66, 0x46, 0xD4, 0xE2, 0x3C, 0x1F, 0x26, 0x09, 0xE2, 0x6E, 0xB8, + 0xFF, 0xFF, 0xFE, 0x58, 0xBB, 0xFF, 0xB8, 0x33, 0xB7, 0xBB, 0xC2, 0x9A, 0x67, 0xC5, 0x6E, 0x23, + 0x38, 0xE5, 0x2B, 0xF7, 0x5D, 0x9C, 0x45, 0xD0, 0xB9, 0x8A, 0x5F, 0x27, 0x6E, 0x8A, 0x14, 0x00, + 0x80, 0x00, 0x1C, 0x64, 0xBA, 0xCC, 0x6F, 0x9F, 0x91, 0x34, 0x9A, 0x2E, 0x07, 0x1C, 0x8B, 0x90, + 0x3C, 0x77, 0xC4, 0xFD, 0x1B, 0x41, 0x61, 0xFF, 0x14, 0x0E, 0x20, 0xFC, 0x62, 0x14, 0x42, 0x08, + 0xFE, 0x46, 0xAB, 0x10, 0x04, 0x17, 0x0C, 0xA3, 0x06, 0x81, 0x51, 0xE7, 0x2A, 0x80, 0x00, 0x05, + 0xD6, 0xB8, 0x66, 0x59, 0x04, 0x60, 0x40, 0xBE, 0x60, 0x09, 0x2A, 0x24, 0xA7, 0x8C, 0x07, 0x66, + 0x89, 0xC6, 0x2C, 0x4C, 0x64, 0xA1, 0x31, 0x84, 0x4C, 0x01, 0x00, 0xFF, 0xFB, 0x90, 0x64, 0x0F, + 0x0F, 0x34, 0x65, 0x34, 0x4E, 0x2B, 0xB9, 0x83, 0xE2, 0x31, 0xC6, 0x99, 0xA8, 0x1C, 0xC5, 0x76, + 0x11, 0x0C, 0xD3, 0x3A, 0x0E, 0x77, 0x2C, 0x10, 0xB8, 0x0E, 0x67, 0x94, 0x82, 0x99, 0x88, 0x26, + 0x30, 0x86, 0x20, 0xE1, 0xB4, 0x0A, 0x42, 0x1C, 0xAE, 0x31, 0x80, 0x81, 0xA1, 0x19, 0x0C, 0x82, + 0xF0, 0xE8, 0x09, 0xB6, 0x0C, 0xA6, 0xA5, 0x03, 0x43, 0x03, 0xD0, 0xBB, 0x82, 0x24, 0x61, 0x92, + 0x50, 0x00, 0xA0, 0xC2, 0xC1, 0x08, 0x3E, 0xCC, 0x44, 0xE4, 0x4D, 0x75, 0x90, 0x94, 0x97, 0x18, + 0x8E, 0x01, 0x83, 0x23, 0x62, 0xBF, 0x8E, 0x50, 0x00, 0xF0, 0xAA, 0xAC, 0x72, 0xBE, 0xEE, 0xA2, + 0x00, 0x70, 0xB1, 0xD5, 0x79, 0x2C, 0x66, 0x32, 0x6E, 0xB1, 0x88, 0x1D, 0xD3, 0x45, 0xB7, 0x8A, + 0x0C, 0xC9, 0xBD, 0x3D, 0x6A, 0x43, 0x2F, 0x12, 0x6B, 0x30, 0x92, 0xAB, 0x48, 0xDD, 0x02, 0x54, + 0xD9, 0xCF, 0x4C, 0xC8, 0x3C, 0x82, 0x13, 0x83, 0xE0, 0x09, 0xE7, 0x05, 0xC0, 0xB0, 0x56, 0x18, + 0x01, 0x04, 0x44, 0x09, 0xF5, 0xB5, 0x04, 0xE4, 0xC6, 0x75, 0xFD, 0x1E, 0xBC, 0xF0, 0x1B, 0x44, + 0x64, 0x0F, 0x57, 0x3D, 0x3E, 0xCE, 0x75, 0x4A, 0x37, 0xFC, 0xCC, 0x0C, 0x28, 0x6E, 0x88, 0x34, + 0x3B, 0x7F, 0x43, 0xFB, 0x74, 0x15, 0xF7, 0x7D, 0xFA, 0x9E, 0x82, 0xE2, 0x60, 0x8A, 0x20, 0xAE, + 0xF2, 0xEC, 0x35, 0x51, 0xFC, 0xC0, 0xC1, 0x23, 0x06, 0x9D, 0x45, 0x9F, 0xC6, 0x0F, 0x00, 0x1D, + 0xCA, 0xA0, 0x64, 0x30, 0x89, 0x80, 0x8E, 0xA6, 0x76, 0x0E, 0xAA, 0xB9, 0x8A, 0x8F, 0xAB, 0xAC, + 0xC7, 0xED, 0xF3, 0xA1, 0x43, 0x00, 0xE0, 0xE8, 0xC1, 0x90, 0x7C, 0x05, 0x34, 0x0A, 0x60, 0x82, + 0xEC, 0x0E, 0x35, 0x35, 0x58, 0x04, 0x3C, 0x32, 0xCA, 0x58, 0xF4, 0x6C, 0xC5, 0x0A, 0xD0, 0xE9, + 0x8B, 0xF1, 0xDE, 0x0E, 0x69, 0xDA, 0x43, 0xB2, 0x2C, 0x52, 0xA8, 0xBE, 0xE2, 0x33, 0xBF, 0xBA, + 0xC4, 0x82, 0x0D, 0x51, 0x27, 0x13, 0x31, 0x67, 0xAB, 0x20, 0x62, 0xF7, 0x50, 0xCA, 0x1D, 0xEE, + 0xBE, 0x27, 0x2E, 0x86, 0x59, 0x74, 0x91, 0x5D, 0x4F, 0xF3, 0xFF, 0xFF, 0x0C, 0xF9, 0xF7, 0xB7, + 0xFF, 0x77, 0xB5, 0x29, 0xF7, 0x73, 0x5C, 0xFD, 0xD8, 0x63, 0x9B, 0xEF, 0xD0, 0xBD, 0xDE, 0xDD, + 0xA8, 0xD9, 0xE9, 0x68, 0x9C, 0x25, 0xD9, 0x60, 0x40, 0x61, 0x83, 0xEC, 0x3B, 0x3F, 0xAD, 0x09, + 0x01, 0x04, 0xC8, 0x02, 0x37, 0x47, 0xFA, 0x20, 0xCF, 0x48, 0xF0, 0x37, 0xE5, 0x98, 0xF0, 0x54, + 0x3D, 0x20, 0xF9, 0xFF, 0x68, 0xB3, 0xC9, 0xEC, 0x18, 0x94, 0xD4, 0xD0, 0x98, 0x8F, 0xED, 0x48, + 0xEE, 0xB6, 0xEE, 0x2C, 0x34, 0x52, 0x70, 0x4B, 0x00, 0x07, 0x63, 0x44, 0x62, 0xA8, 0x03, 0x12, + 0xE6, 0x1E, 0x20, 0x60, 0x30, 0x02, 0x71, 0xD8, 0x6E, 0x61, 0xA0, 0x1C, 0x60, 0xA0, 0x0A, 0x65, + 0x50, 0x80, 0xAA, 0x06, 0x07, 0x1E, 0x82, 0x00, 0x50, 0x45, 0x2E, 0x9D, 0xFF, 0xFB, 0x92, 0x64, + 0x13, 0x0F, 0x04, 0x87, 0x34, 0xCD, 0x83, 0x7D, 0xD1, 0x40, 0x30, 0x62, 0x4A, 0x5E, 0x3C, 0x6D, + 0x18, 0x10, 0xF4, 0xD3, 0x36, 0x0E, 0x65, 0xEF, 0x40, 0xC5, 0x0D, 0x66, 0xA0, 0xC2, 0x99, 0x98, + 0x46, 0x42, 0x2C, 0x53, 0x02, 0x07, 0x32, 0x87, 0x8D, 0x78, 0xBD, 0x2B, 0x75, 0x26, 0x87, 0x8E, + 0x55, 0x49, 0x4A, 0xEE, 0x54, 0x2D, 0xB8, 0x82, 0x82, 0xD1, 0x28, 0xD0, 0xB2, 0x86, 0xAA, 0x86, + 0xAF, 0x90, 0x20, 0xE1, 0x90, 0x07, 0x1B, 0x43, 0x84, 0x73, 0xF9, 0xAC, 0xA9, 0x48, 0x48, 0x08, + 0x47, 0xB7, 0xE6, 0x76, 0x22, 0x9A, 0x28, 0xE9, 0xA9, 0x08, 0xE9, 0x40, 0x6E, 0xA4, 0xFE, 0xB6, + 0xD1, 0xE4, 0x16, 0x20, 0x5A, 0x09, 0x5D, 0x1F, 0xFF, 0xFD, 0xEC, 0xA4, 0xB3, 0xB9, 0x5D, 0xAD, + 0xFD, 0xC7, 0x0D, 0xDF, 0xFC, 0xA1, 0xBA, 0xF3, 0xF7, 0xD8, 0x44, 0x03, 0x10, 0x94, 0x58, 0x94, + 0xDC, 0xC1, 0xDB, 0x79, 0xA0, 0x60, 0xC0, 0xAD, 0x76, 0x72, 0x4C, 0xA6, 0x12, 0x00, 0x00, 0x50, + 0xA8, 0x1C, 0x01, 0x29, 0x32, 0x16, 0x77, 0xE3, 0x19, 0x5A, 0xF5, 0x46, 0xE1, 0x67, 0x53, 0x99, + 0x00, 0xED, 0x08, 0xB0, 0x5C, 0x86, 0x9A, 0x37, 0x31, 0x73, 0x73, 0xCE, 0x6A, 0x02, 0x3D, 0xE0, + 0x50, 0x6C, 0x42, 0x6F, 0x6D, 0x7A, 0x94, 0xFE, 0xEE, 0xAE, 0x9A, 0x65, 0x69, 0x48, 0x67, 0xC5, + 0x38, 0xC8, 0x14, 0x08, 0x97, 0x35, 0xD1, 0x98, 0x08, 0x09, 0x3F, 0x67, 0xEC, 0xCB, 0x63, 0x50, + 0xA0, 0xF4, 0xCA, 0xC5, 0xF1, 0x00, 0x68, 0xC8, 0x29, 0x53, 0x03, 0x0A, 0x0D, 0x09, 0x1D, 0x0B, + 0xAC, 0x8C, 0x10, 0x0F, 0x64, 0xA3, 0xDE, 0x26, 0x30, 0x30, 0x95, 0x9B, 0x20, 0x1A, 0x36, 0x1A, + 0x43, 0x8C, 0x0D, 0x11, 0x79, 0xFA, 0x5C, 0x28, 0x42, 0xAB, 0x29, 0xDC, 0xF3, 0x50, 0x71, 0x01, + 0x27, 0x07, 0x1E, 0xCD, 0x95, 0x41, 0xAE, 0x4E, 0xE7, 0xFF, 0x62, 0x5E, 0x44, 0xB0, 0x30, 0x74, + 0x15, 0x26, 0x45, 0xEB, 0x1F, 0x72, 0x0E, 0x09, 0x28, 0x11, 0x35, 0x76, 0x35, 0x4A, 0x81, 0xA0, + 0xC0, 0x63, 0x68, 0xB7, 0xFF, 0xC7, 0xAB, 0xD9, 0x27, 0x51, 0xB1, 0xFF, 0xFE, 0xB1, 0xF2, 0x7C, + 0x37, 0x3C, 0x9D, 0x68, 0x57, 0x92, 0x0A, 0x85, 0x1C, 0x64, 0x0F, 0x2A, 0x5F, 0xB0, 0x06, 0xA8, + 0x43, 0xF2, 0xE2, 0x84, 0x00, 0x00, 0x00, 0xB4, 0xAC, 0x7F, 0xA0, 0xB2, 0x0C, 0xFA, 0x57, 0x9F, + 0xA9, 0xEC, 0x8A, 0x80, 0x7E, 0x93, 0x07, 0x9C, 0xA6, 0xF3, 0x38, 0x28, 0x4F, 0x06, 0x8D, 0x2D, + 0x55, 0xBF, 0xFE, 0xC2, 0x57, 0xDA, 0x80, 0x42, 0x84, 0xB3, 0xB2, 0xAE, 0xCB, 0x74, 0xEF, 0x80, + 0x0F, 0x9C, 0xA6, 0x0A, 0xD5, 0x86, 0x48, 0x41, 0x63, 0x13, 0x4D, 0x23, 0x03, 0x01, 0x53, 0x02, + 0x80, 0x40, 0x54, 0xA2, 0x60, 0x50, 0x74, 0x66, 0x1D, 0x54, 0x63, 0xC0, 0xD0, 0x20, 0x00, 0x07, + 0x85, 0xA3, 0x08, 0xC1, 0xB3, 0x03, 0x51, 0x52, 0xB1, 0xDC, 0x28, 0x0C, 0x99, 0xEC, 0xFF, 0xFB, + 0x92, 0x64, 0x14, 0x8F, 0x14, 0x5C, 0x34, 0xCD, 0x83, 0xB8, 0x7C, 0x50, 0x31, 0x26, 0x09, 0x69, + 0x18, 0xE6, 0x8C, 0x10, 0xE0, 0xD3, 0x36, 0x0E, 0x65, 0xED, 0x80, 0xCD, 0x19, 0xA6, 0x50, 0x72, + 0x8E, 0x31, 0x3B, 0x94, 0x02, 0x05, 0x50, 0x48, 0x88, 0x51, 0xF2, 0xD7, 0x4A, 0x67, 0x06, 0xB9, + 0x1C, 0x43, 0xA6, 0x70, 0x0C, 0x39, 0x3C, 0x40, 0x55, 0x96, 0x88, 0x64, 0xC2, 0x89, 0xAD, 0x48, + 0x65, 0x40, 0x80, 0xA8, 0x89, 0x4B, 0x03, 0x0B, 0xFA, 0xFF, 0xBE, 0xB0, 0xE5, 0x5E, 0xA9, 0x09, + 0x42, 0xD1, 0x6E, 0xE0, 0x94, 0x0B, 0xB1, 0x50, 0x09, 0x17, 0x5B, 0x7A, 0xE4, 0x31, 0x28, 0xC4, + 0x05, 0x47, 0x16, 0xFF, 0xFF, 0xD4, 0x4A, 0x3E, 0x86, 0xF5, 0x5D, 0xFD, 0xF5, 0xEF, 0x55, 0x19, + 0xE2, 0x40, 0xD6, 0x76, 0x5F, 0x0D, 0xE4, 0x39, 0xC4, 0xD2, 0x4E, 0x56, 0xF3, 0x23, 0x86, 0xFA, + 0x0C, 0x1B, 0xC2, 0x97, 0x80, 0x10, 0x01, 0x80, 0x30, 0x03, 0xC5, 0x9A, 0x8D, 0x6F, 0x7A, 0xF9, + 0x4E, 0xC4, 0xAE, 0xE0, 0x40, 0xCE, 0xBF, 0x46, 0x74, 0x77, 0xCF, 0x75, 0x54, 0xFA, 0x01, 0xC2, + 0xE1, 0xC3, 0x1C, 0xD5, 0x33, 0xA1, 0x8D, 0xD0, 0xC6, 0x5F, 0xB7, 0xFF, 0x9D, 0x88, 0x64, 0x10, + 0x98, 0xF7, 0x7A, 0x03, 0x6C, 0xBC, 0xA8, 0x40, 0x05, 0x32, 0xBC, 0x06, 0x1E, 0x06, 0xA7, 0x8C, + 0x08, 0x87, 0x01, 0x0C, 0x0D, 0x07, 0x49, 0x3C, 0x11, 0x68, 0xA8, 0x46, 0x33, 0x41, 0x08, 0x60, + 0x4E, 0x64, 0x01, 0xC8, 0xD6, 0x8C, 0xC2, 0x00, 0x23, 0x43, 0x05, 0x36, 0x2D, 0x10, 0xB5, 0xAF, + 0xEB, 0xF3, 0x55, 0x6C, 0x16, 0x4E, 0x79, 0x79, 0x4A, 0xEE, 0x23, 0x2B, 0xE6, 0xB0, 0x60, 0x23, + 0x16, 0x4A, 0x24, 0xD1, 0x37, 0x46, 0x34, 0xE8, 0xA7, 0xF2, 0xD3, 0x6E, 0x49, 0xA5, 0x62, 0xEF, + 0x75, 0x4A, 0xB5, 0x07, 0x17, 0x1E, 0xF2, 0x7E, 0xC8, 0x20, 0x24, 0x12, 0x0A, 0x36, 0x33, 0x0B, + 0x93, 0x27, 0x3B, 0x5D, 0x73, 0x9D, 0x4D, 0x3C, 0x1F, 0xF1, 0xAB, 0xC3, 0x89, 0x0B, 0x72, 0xC6, + 0x65, 0x93, 0xC1, 0x85, 0xE0, 0xC7, 0x1C, 0xA4, 0xC1, 0x3A, 0x44, 0x16, 0x34, 0x52, 0x84, 0xC6, + 0xB1, 0xC2, 0x5F, 0xAC, 0xF2, 0x51, 0xD8, 0xCC, 0x5F, 0x09, 0x38, 0xE2, 0xC8, 0x0C, 0x01, 0x10, + 0xC1, 0x41, 0x79, 0x7A, 0xFF, 0xD7, 0x02, 0x8E, 0x50, 0x9F, 0xAF, 0x39, 0x33, 0x9D, 0xCE, 0xEA, + 0x12, 0x1F, 0x9C, 0xF4, 0x31, 0x03, 0xE3, 0xB1, 0xA3, 0x94, 0x3F, 0x18, 0x8D, 0x56, 0x41, 0xFF, + 0xA7, 0xF2, 0x07, 0x2A, 0x00, 0x00, 0x44, 0x10, 0x5D, 0x08, 0xB0, 0x04, 0xE7, 0x0E, 0x08, 0x80, + 0x4C, 0x13, 0x02, 0x43, 0x63, 0x4C, 0x93, 0x00, 0x84, 0x48, 0xC3, 0x10, 0x88, 0xE1, 0x70, 0x24, + 0xC4, 0xF1, 0x6C, 0xC9, 0xFE, 0x84, 0xFD, 0x83, 0x8D, 0x01, 0x10, 0xC2, 0xD3, 0xCC, 0x40, 0x14, + 0xD9, 0xE2, 0x8E, 0xDC, 0xF0, 0x48, 0x70, 0xB4, 0x61, 0x92, 0x0D, 0x10, 0x4D, 0x4D, 0x04, 0x4A, + 0xFF, 0xFB, 0x92, 0x64, 0x18, 0x0F, 0x04, 0xBA, 0x34, 0xCC, 0x03, 0xBB, 0xC9, 0xA0, 0x2F, 0x86, + 0x89, 0xC8, 0x15, 0x02, 0x68, 0x12, 0x8C, 0xCF, 0x30, 0x0E, 0xEB, 0x08, 0xC8, 0xCB, 0x19, 0xE6, + 0xE0, 0x71, 0x89, 0xB0, 0x4A, 0xB9, 0x88, 0x0E, 0x91, 0x2F, 0xA6, 0x2F, 0x9A, 0x95, 0x29, 0x24, + 0xE9, 0x02, 0x9F, 0x15, 0x5D, 0x88, 0x0C, 0x7E, 0x90, 0x43, 0x2C, 0x94, 0x8F, 0x7C, 0xA4, 0xDD, + 0xD6, 0x03, 0x2E, 0x5D, 0x19, 0xC1, 0x8B, 0x6D, 0x42, 0x4C, 0x3C, 0x04, 0xEF, 0x8A, 0x03, 0x1B, + 0x07, 0x28, 0x14, 0x54, 0xE0, 0x00, 0x0C, 0x83, 0x40, 0x90, 0x59, 0x5C, 0x39, 0xA6, 0x8C, 0x27, + 0xBF, 0xFF, 0x25, 0xAB, 0x6A, 0x51, 0x4C, 0xE3, 0x6A, 0x67, 0x2C, 0xA2, 0x59, 0x55, 0x88, 0xF3, + 0xED, 0xCF, 0x21, 0x5B, 0xC8, 0x8F, 0xE5, 0xC0, 0x7A, 0x0B, 0xC0, 0xD5, 0xE2, 0x0D, 0x5D, 0x90, + 0xD2, 0xC7, 0xEB, 0xCC, 0xA1, 0x62, 0x03, 0xC2, 0xE0, 0x3F, 0x37, 0x80, 0x00, 0x30, 0x00, 0x0C, + 0x02, 0x8B, 0x43, 0x8D, 0xFE, 0xAF, 0xB0, 0x54, 0xA6, 0xFF, 0x81, 0xDC, 0x39, 0x47, 0xC8, 0xC6, + 0x64, 0x9E, 0x6B, 0x11, 0xF5, 0x70, 0xB6, 0x21, 0x54, 0x38, 0x2A, 0x20, 0xEC, 0xBF, 0xA7, 0xFE, + 0xFD, 0x11, 0xA3, 0x91, 0x82, 0xBD, 0x5D, 0x68, 0xCA, 0xA0, 0xD9, 0x47, 0x8C, 0x00, 0x0D, 0x4D, + 0xBD, 0x1E, 0x8C, 0x96, 0x0E, 0xCC, 0x57, 0x58, 0x4C, 0xFD, 0x34, 0x0C, 0x1B, 0x0B, 0xCD, 0x62, + 0x92, 0x4D, 0x3F, 0x03, 0x4C, 0x2C, 0x0D, 0xCE, 0x02, 0x00, 0x20, 0x63, 0x35, 0x2C, 0x46, 0xD4, + 0x52, 0x68, 0x55, 0xA8, 0xF0, 0x51, 0xE3, 0x21, 0x11, 0x27, 0xA9, 0x62, 0x08, 0x0C, 0x56, 0xF8, + 0x42, 0xC1, 0xBA, 0xCD, 0x95, 0x5D, 0x30, 0x24, 0x0C, 0x2E, 0x74, 0x68, 0x28, 0x54, 0x58, 0x2F, + 0x10, 0x61, 0x25, 0x84, 0xB7, 0x29, 0x02, 0xEB, 0x33, 0x0D, 0x95, 0x4F, 0x30, 0x7A, 0x38, 0xF3, + 0xB4, 0xD6, 0x8C, 0x20, 0x54, 0xEE, 0x7B, 0x07, 0x41, 0x91, 0xAB, 0x08, 0xE0, 0x5B, 0x71, 0xEA, + 0x37, 0x65, 0x18, 0x86, 0xA0, 0x06, 0x17, 0x3B, 0x6B, 0x9F, 0xF1, 0xF8, 0xFD, 0x1C, 0x71, 0x64, + 0xBE, 0xBC, 0xCB, 0xFF, 0x9A, 0xAA, 0xF7, 0xF7, 0x98, 0x40, 0x28, 0xAB, 0x25, 0x5B, 0x29, 0x02, + 0xD6, 0x53, 0x2A, 0x45, 0xDB, 0xF4, 0xD6, 0xA0, 0xAA, 0xF4, 0x71, 0xA7, 0xDD, 0x1F, 0x45, 0xC0, + 0x00, 0x00, 0x14, 0x08, 0xC3, 0x67, 0x60, 0x73, 0xFF, 0x14, 0x0F, 0x67, 0x35, 0x71, 0x7C, 0x33, + 0xAE, 0x48, 0x38, 0x52, 0xDF, 0x53, 0x0E, 0x32, 0x84, 0x14, 0x68, 0x3A, 0xF0, 0x53, 0x8E, 0xE1, + 0x1C, 0x5A, 0xB4, 0xA5, 0xFE, 0x7B, 0x04, 0xFC, 0xAF, 0xE1, 0xD6, 0xCC, 0x25, 0xF5, 0x6A, 0x55, + 0x00, 0x51, 0x51, 0xE1, 0x42, 0x09, 0xE8, 0x32, 0x66, 0x9D, 0x29, 0x19, 0xB2, 0x5E, 0x62, 0x96, + 0x28, 0xC8, 0xD0, 0x13, 0xF2, 0x39, 0xEB, 0x8E, 0x75, 0x43, 0x05, 0x14, 0x2E, 0x1C, 0xCD, 0x01, + 0x2D, 0x01, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x0F, 0xB4, 0x48, 0x34, 0xCC, 0x03, 0x9A, 0xC1, 0xB0, + 0x30, 0x26, 0x79, 0x80, 0x14, 0xC2, 0x6C, 0x50, 0x88, 0xD1, 0x32, 0x0E, 0xE9, 0xE9, 0xC0, 0xC7, + 0x99, 0xE4, 0xA0, 0x73, 0x2A, 0x10, 0x92, 0x16, 0x19, 0x44, 0x8A, 0x9A, 0x5A, 0x04, 0x16, 0x1F, + 0x78, 0xEF, 0xA3, 0x33, 0x50, 0x8E, 0xC6, 0x6C, 0xCB, 0x53, 0xAD, 0xB9, 0x0F, 0x09, 0x56, 0x09, + 0x30, 0x0F, 0x96, 0x06, 0xC6, 0x11, 0xE5, 0xE0, 0x00, 0x64, 0x22, 0x2F, 0x28, 0x2D, 0xF0, 0x14, + 0x9A, 0xBD, 0x25, 0x4A, 0x02, 0xFC, 0xB3, 0xE3, 0x68, 0x20, 0x78, 0x1D, 0x69, 0x37, 0x55, 0x14, + 0x5D, 0xED, 0x75, 0x04, 0x8A, 0x86, 0x5A, 0xE9, 0x3D, 0x5A, 0xCA, 0xDF, 0xFC, 0x66, 0xC4, 0x6E, + 0x82, 0x4F, 0x15, 0xBF, 0xFF, 0xBE, 0xF3, 0x52, 0xAE, 0xCD, 0x72, 0xE2, 0x8D, 0x50, 0xB4, 0x95, + 0x71, 0x43, 0x06, 0xDF, 0x95, 0xCC, 0x67, 0xBA, 0x5A, 0x5A, 0xDA, 0x8B, 0x48, 0x25, 0xDC, 0x76, + 0xA0, 0x93, 0xFF, 0x80, 0xCB, 0x74, 0x7B, 0xE3, 0xB7, 0xC3, 0xBE, 0x6B, 0xA2, 0x3C, 0x25, 0xE6, + 0xB6, 0xC5, 0x4E, 0x1B, 0x3F, 0xFE, 0x51, 0xE3, 0x4E, 0x7F, 0x20, 0xC2, 0xC8, 0x72, 0xB3, 0x27, + 0xF1, 0x48, 0xB5, 0x6F, 0x62, 0xFC, 0x39, 0x42, 0x8C, 0x60, 0x5D, 0x55, 0xB5, 0x0A, 0x93, 0x2E, + 0x50, 0x28, 0x60, 0x66, 0x7C, 0x0C, 0x34, 0x12, 0x18, 0x6C, 0x03, 0x9A, 0x54, 0x64, 0x18, 0x00, + 0x35, 0x99, 0x72, 0x4B, 0x99, 0x18, 0x02, 0x98, 0xA6, 0x2C, 0x1E, 0x30, 0x66, 0x28, 0x99, 0xD0, + 0xDC, 0x48, 0x3C, 0x1A, 0x5C, 0xD3, 0xDA, 0x08, 0x2E, 0x61, 0xC8, 0x19, 0x72, 0xEC, 0xB9, 0x35, + 0x55, 0xAD, 0x19, 0xA7, 0x29, 0x6B, 0x63, 0x2A, 0x8B, 0x41, 0xE8, 0x83, 0x1A, 0x6B, 0xCE, 0xDA, + 0xC0, 0x47, 0x29, 0x6D, 0x01, 0x97, 0x3D, 0x6D, 0x8C, 0x39, 0x7B, 0xFB, 0x20, 0xA9, 0x2B, 0x8B, + 0x19, 0x0E, 0x43, 0x84, 0x8C, 0xE3, 0x45, 0x97, 0xE6, 0x44, 0x3C, 0x50, 0xBD, 0x1D, 0x47, 0x86, + 0xA6, 0x3F, 0x2D, 0x96, 0xCF, 0xD1, 0x6C, 0x96, 0x39, 0xF5, 0x0F, 0x1F, 0x37, 0x5C, 0xEB, 0x0B, + 0x1E, 0x14, 0x49, 0x91, 0xEB, 0xBA, 0x17, 0x34, 0x1A, 0xA9, 0x81, 0x7D, 0x5A, 0xCF, 0xBF, 0xBF, + 0x96, 0x63, 0xF2, 0xA1, 0x80, 0xA0, 0x3B, 0xFF, 0xD8, 0xED, 0x15, 0xBF, 0xD4, 0xCA, 0x44, 0xB4, + 0x98, 0xF6, 0x1C, 0x58, 0x2A, 0x41, 0x54, 0x5E, 0x01, 0xA2, 0x8E, 0x63, 0xA3, 0x21, 0xE0, 0xDD, + 0x94, 0x1E, 0xAA, 0xBC, 0xA0, 0xEF, 0xF5, 0x53, 0x72, 0x36, 0xF2, 0x5F, 0x9D, 0x44, 0x26, 0x25, + 0x6D, 0x5F, 0x6B, 0x10, 0x8B, 0x95, 0x9E, 0x00, 0x00, 0x26, 0x20, 0x46, 0x26, 0x11, 0x09, 0xE6, + 0x00, 0x92, 0xC7, 0x2A, 0x0C, 0xE6, 0x17, 0x32, 0x9B, 0x5B, 0xBE, 0x65, 0xD0, 0x19, 0x82, 0xC2, + 0x63, 0xE0, 0xB3, 0x05, 0x80, 0x82, 0x9E, 0x8D, 0x91, 0x63, 0x40, 0xAC, 0xEC, 0x13, 0x2C, 0x01, + 0x6B, 0x84, 0xCD, 0xC2, 0xFF, 0xFB, 0x92, 0x64, 0x17, 0x0F, 0x34, 0x72, 0x34, 0x4C, 0x83, 0xBC, + 0xD1, 0x20, 0x32, 0x46, 0x69, 0x18, 0x09, 0x6A, 0x96, 0x50, 0xA8, 0xCF, 0x34, 0x0E, 0x6B, 0x06, + 0x48, 0xB1, 0x99, 0xA6, 0x14, 0x73, 0x09, 0xEA, 0x82, 0x55, 0x95, 0x4D, 0x99, 0xEA, 0xE1, 0x86, + 0x57, 0xAD, 0xB7, 0xAD, 0xAF, 0x4B, 0xA5, 0xF5, 0xD0, 0x70, 0x30, 0xDA, 0xB8, 0x92, 0x5F, 0x66, + 0x6B, 0x12, 0x10, 0x23, 0x02, 0x11, 0xA9, 0xF4, 0x94, 0x42, 0x23, 0xF1, 0x47, 0xD5, 0xF6, 0x6A, + 0xF0, 0xD8, 0x38, 0x04, 0xA4, 0x18, 0x15, 0x8E, 0x45, 0x55, 0xEE, 0x69, 0x52, 0xE9, 0xED, 0xD7, + 0xA9, 0xFB, 0xAB, 0xCF, 0xFA, 0x5A, 0x09, 0x46, 0x37, 0x70, 0xC2, 0x63, 0x54, 0x38, 0x7D, 0x3D, + 0xEB, 0xB7, 0xBC, 0x94, 0x2D, 0xA5, 0x86, 0x41, 0x33, 0x7C, 0xD8, 0xD3, 0x82, 0x65, 0x25, 0x58, + 0xFF, 0xC7, 0x39, 0xA8, 0xC4, 0x1A, 0x98, 0xF6, 0x80, 0x01, 0x60, 0x00, 0x01, 0x0B, 0xFA, 0x31, + 0x3D, 0x1B, 0x3D, 0xB9, 0x48, 0xD9, 0x34, 0xA1, 0xF5, 0x2E, 0xE8, 0x62, 0x0E, 0xCA, 0xDD, 0x5F, + 0xE2, 0x3D, 0xC4, 0x6A, 0xA2, 0xCD, 0xCC, 0x0D, 0x02, 0xF1, 0xE8, 0xFF, 0xF1, 0xFE, 0xA3, 0xF4, + 0xE7, 0x7D, 0x79, 0xE6, 0x16, 0xCA, 0xA6, 0x87, 0x8C, 0x19, 0xA7, 0x74, 0x12, 0x0C, 0x32, 0xC6, + 0x90, 0x20, 0x3E, 0x62, 0x87, 0xE1, 0xC3, 0x0C, 0xA6, 0x1B, 0x10, 0x1B, 0x0B, 0xF0, 0x77, 0x41, + 0x02, 0x32, 0x9C, 0x92, 0x06, 0x04, 0x09, 0x89, 0x20, 0xF2, 0x25, 0xD8, 0x1F, 0xD0, 0xEB, 0xA4, + 0x4E, 0x79, 0x6A, 0x56, 0x3F, 0x8E, 0x68, 0x9B, 0x6F, 0x37, 0x0C, 0x5E, 0x94, 0x80, 0xC5, 0x0E, + 0x6E, 0x6B, 0x2C, 0x4B, 0xC5, 0x16, 0x53, 0x78, 0x7D, 0xB2, 0xA6, 0xBC, 0xC1, 0x50, 0xEB, 0xFA, + 0x18, 0x47, 0x7A, 0x76, 0xC6, 0xF4, 0xBF, 0x75, 0x87, 0x4C, 0xD9, 0x0A, 0xA3, 0xA7, 0x4F, 0xC5, + 0xB8, 0xC4, 0xEE, 0xE2, 0x88, 0xCC, 0xEA, 0xEC, 0xEC, 0xC5, 0x2E, 0x1F, 0xFF, 0xFD, 0xD4, 0xBB, + 0x0E, 0xE3, 0x41, 0x77, 0xFF, 0xF9, 0x25, 0xBD, 0x57, 0xF2, 0x24, 0x0A, 0x30, 0xBE, 0x82, 0x11, + 0xC8, 0x29, 0x55, 0xA7, 0x8B, 0x08, 0xB8, 0xAE, 0x3F, 0xB6, 0x6A, 0x48, 0x65, 0x2A, 0xAC, 0x20, + 0x42, 0x4B, 0xFD, 0x41, 0x78, 0x63, 0xA9, 0x36, 0xCD, 0x0B, 0xB1, 0x19, 0xFB, 0x2E, 0x0C, 0xE4, + 0xFC, 0x3B, 0x4C, 0x73, 0x23, 0x1F, 0x5B, 0x19, 0xA2, 0x08, 0x19, 0x19, 0x7A, 0x8C, 0xDF, 0xFC, + 0x81, 0x52, 0xA6, 0xDB, 0xFF, 0x08, 0xC7, 0x76, 0xA3, 0x52, 0x0C, 0x3A, 0xAA, 0x19, 0x02, 0x08, + 0x86, 0xE7, 0x8D, 0xF2, 0x96, 0x04, 0x66, 0x0D, 0xD7, 0x1C, 0x7C, 0xF6, 0x00, 0x07, 0x1E, 0x9E, + 0x24, 0x74, 0x03, 0x51, 0x8E, 0x89, 0xC7, 0x81, 0x08, 0x62, 0x82, 0x25, 0xC1, 0x90, 0x18, 0xF8, + 0x30, 0x6B, 0x03, 0xB0, 0x89, 0xC2, 0x55, 0x37, 0x46, 0xF1, 0x76, 0xA8, 0x00, 0x74, 0xAF, 0x83, + 0xB7, 0x79, 0xD0, 0x28, 0x07, 0x01, 0xFF, 0xFB, 0x92, 0x64, 0x1C, 0x8F, 0x34, 0x9A, 0x34, 0xCC, + 0x03, 0x9B, 0xCA, 0x20, 0x2F, 0xC6, 0x09, 0xA8, 0x14, 0x62, 0x7A, 0x51, 0xE8, 0xD1, 0x30, 0x0E, + 0xEF, 0x26, 0xC0, 0xB8, 0x1A, 0x25, 0x94, 0x71, 0x96, 0x22, 0x41, 0xDE, 0xF4, 0xC3, 0x47, 0xB2, + 0x01, 0x80, 0xC7, 0xBB, 0xEC, 0x0C, 0xBD, 0x30, 0xF9, 0x08, 0xEE, 0xE7, 0x56, 0x0D, 0x46, 0x5B, + 0x19, 0xC6, 0x8B, 0x20, 0x11, 0x00, 0x92, 0xE0, 0xC0, 0x4C, 0x31, 0x21, 0xB0, 0xB2, 0xCF, 0x5A, + 0x81, 0x37, 0x47, 0xD5, 0x88, 0xB4, 0x18, 0x25, 0x6F, 0x4E, 0x48, 0x5D, 0x4B, 0xDD, 0xFD, 0x54, + 0xE3, 0xA1, 0x1B, 0xEF, 0xD6, 0xC3, 0xFF, 0xF9, 0x25, 0xBD, 0xFC, 0xBE, 0xD9, 0x45, 0x99, 0x5D, + 0x80, 0xC1, 0xC0, 0xC2, 0x35, 0xD6, 0x0E, 0xCC, 0x11, 0xDA, 0x2D, 0xC6, 0xFA, 0xBD, 0x1A, 0x78, + 0x53, 0x24, 0x5C, 0xEF, 0x40, 0xCC, 0x80, 0x00, 0x0F, 0xFA, 0x00, 0x02, 0xAF, 0xC3, 0xAF, 0x84, + 0x78, 0xC5, 0xEF, 0xB2, 0x55, 0x47, 0x11, 0x81, 0x23, 0x31, 0x74, 0x40, 0xE5, 0x1B, 0x26, 0x06, + 0x3C, 0x40, 0x87, 0xA2, 0xD5, 0xCB, 0xFA, 0xD5, 0xF4, 0x56, 0xFF, 0x42, 0x86, 0x38, 0xA0, 0x6D, + 0x0B, 0xD6, 0x2D, 0x93, 0x7F, 0x0C, 0x01, 0x03, 0x4E, 0x18, 0x5A, 0x03, 0x0A, 0xA1, 0x19, 0xE0, + 0x73, 0x88, 0x42, 0x61, 0xC8, 0x5E, 0x66, 0x26, 0x7A, 0x6A, 0xD3, 0xE6, 0x4A, 0x54, 0x69, 0xCE, + 0xE4, 0xC1, 0x82, 0x15, 0x34, 0x45, 0x30, 0xA4, 0x23, 0x4F, 0x43, 0x53, 0x24, 0x90, 0x07, 0x36, + 0xC2, 0xE5, 0xCF, 0x4A, 0x5A, 0x2B, 0x0B, 0x72, 0x4D, 0x4D, 0xAD, 0x88, 0x16, 0x54, 0x9A, 0x10, + 0xF0, 0x58, 0xF0, 0xE0, 0x89, 0x42, 0x7F, 0x57, 0xC3, 0x4D, 0x16, 0x0A, 0x7C, 0x46, 0xCB, 0x9B, + 0x40, 0x38, 0x54, 0x58, 0xC3, 0x7C, 0x4F, 0x27, 0x84, 0x21, 0xB5, 0xAF, 0x7C, 0x8A, 0xD8, 0xA1, + 0x0B, 0x03, 0x47, 0x2C, 0x0A, 0xCB, 0x8C, 0xB2, 0xBB, 0x54, 0x09, 0x83, 0x7B, 0xB0, 0x98, 0x86, + 0xB9, 0xF5, 0x78, 0xEF, 0xBE, 0x7D, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xD4, 0x6C, 0x61, 0xAC, + 0x80, 0x28, 0x01, 0x6D, 0x4B, 0x96, 0xCA, 0x12, 0xFD, 0x99, 0x3F, 0x17, 0xEB, 0x56, 0xC1, 0xB5, + 0xBC, 0x99, 0x97, 0xC1, 0x05, 0xBE, 0x80, 0x0C, 0x59, 0xF4, 0x07, 0xCF, 0x8D, 0x8E, 0x50, 0xAC, + 0x20, 0xEE, 0xC2, 0xD0, 0x65, 0xFA, 0x53, 0xFD, 0xAF, 0x56, 0x01, 0x55, 0xC2, 0xA8, 0x9F, 0x0E, + 0x89, 0xA1, 0xB2, 0xB7, 0xD4, 0xD0, 0x75, 0xFF, 0xFE, 0x62, 0x16, 0xDE, 0xB0, 0x18, 0x71, 0x44, + 0x45, 0xAA, 0x5B, 0xE1, 0x60, 0xC4, 0xE5, 0xD0, 0x7C, 0x58, 0x65, 0x31, 0xBC, 0x83, 0x39, 0x94, + 0x14, 0x30, 0xCC, 0x34, 0x34, 0x02, 0x2E, 0x3D, 0xD3, 0x03, 0x04, 0x46, 0x38, 0xF6, 0x50, 0x52, + 0xD1, 0x90, 0x30, 0x19, 0x78, 0x49, 0x8D, 0x99, 0x9C, 0xAA, 0x12, 0xC7, 0x31, 0x30, 0xB5, 0x02, + 0x55, 0x37, 0x32, 0xCA, 0xD8, 0x52, 0xC8, 0xD3, 0xFF, 0xFB, 0x92, 0x64, 0x1B, 0x0F, 0xB4, 0x87, + 0x34, 0x4C, 0x03, 0xBB, 0xC9, 0xB0, 0x32, 0xA6, 0x89, 0x25, 0x05, 0x87, 0x74, 0x11, 0xD8, 0xD3, + 0x30, 0x0E, 0xF3, 0x42, 0xC0, 0xC3, 0x97, 0xE4, 0xC0, 0x90, 0x1C, 0x30, 0x7F, 0x69, 0x3B, 0x93, + 0x8F, 0x05, 0x4D, 0x0C, 0x2E, 0xF7, 0x61, 0x7D, 0x11, 0x08, 0xCA, 0x57, 0x92, 0x70, 0xBE, 0xC2, + 0x08, 0xD1, 0x1D, 0x59, 0x00, 0x08, 0xB5, 0x83, 0x02, 0x91, 0x75, 0xE7, 0x41, 0x46, 0x34, 0x75, + 0x2F, 0x1E, 0x83, 0x60, 0xDA, 0x5B, 0x03, 0x52, 0x86, 0x1D, 0x74, 0x3F, 0x81, 0xDF, 0x42, 0xFD, + 0xCB, 0xAF, 0xD7, 0x75, 0xA8, 0xBF, 0x52, 0x7F, 0x7D, 0x25, 0x5C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFD, 0xAB, 0x73, 0xC9, 0x04, 0x84, 0x55, 0x0C, 0x24, 0x6B, 0x45, 0x60, 0xA5, 0xB5, 0x6A, 0xDF, + 0xAA, 0xCC, 0x26, 0xD4, 0x15, 0x3B, 0x46, 0x08, 0x80, 0x03, 0x7F, 0xAA, 0xFF, 0x2C, 0x50, 0xF9, + 0x62, 0x91, 0x34, 0x44, 0x58, 0x8E, 0xE7, 0x7E, 0x61, 0xA2, 0x5E, 0x38, 0x34, 0x21, 0x5F, 0xFE, + 0x95, 0x61, 0xA3, 0x8F, 0xB8, 0xD4, 0x5F, 0xF9, 0x50, 0x7C, 0x44, 0xAF, 0xFF, 0xD0, 0xB5, 0x44, + 0x76, 0x76, 0x08, 0x01, 0xC3, 0x68, 0x60, 0x66, 0x71, 0x16, 0x7E, 0x4A, 0x0F, 0x9C, 0x88, 0x8F, + 0x8D, 0x18, 0x43, 0x17, 0xF3, 0xDD, 0x8C, 0x8C, 0x32, 0x07, 0x39, 0xBA, 0x98, 0xD1, 0x06, 0x43, + 0x36, 0x1A, 0xCD, 0x2A, 0x66, 0x11, 0x82, 0xCD, 0xA9, 0x63, 0x04, 0x78, 0xDB, 0xCD, 0x33, 0xC8, + 0x51, 0xD8, 0x69, 0xAB, 0x4D, 0xBB, 0x25, 0xDB, 0xE0, 0xA1, 0x32, 0x99, 0x6E, 0x4F, 0x40, 0xF1, + 0x3B, 0xA8, 0xBF, 0x29, 0x51, 0x51, 0xE6, 0x0F, 0x02, 0x88, 0x5E, 0x6C, 0x4C, 0xDE, 0x7C, 0x50, + 0x29, 0x59, 0x34, 0xDB, 0x33, 0x23, 0x17, 0xA8, 0xE1, 0x52, 0x71, 0xD1, 0x80, 0xE1, 0xCD, 0xAC, + 0xE8, 0x93, 0xD4, 0x9C, 0x32, 0x00, 0x10, 0x56, 0x60, 0xBB, 0x0A, 0x2F, 0x06, 0x36, 0xF8, 0x13, + 0x16, 0x85, 0xBA, 0xB2, 0x19, 0x65, 0x9F, 0xD4, 0x9F, 0xEE, 0xD9, 0xE7, 0xFF, 0xFF, 0xFF, 0xEF, + 0xBF, 0xFE, 0xB0, 0x8A, 0x11, 0x00, 0x84, 0x30, 0x7E, 0x52, 0x95, 0xB6, 0x76, 0x98, 0x73, 0xCB, + 0xFB, 0xAB, 0x00, 0x4B, 0xE9, 0xDE, 0x69, 0x57, 0x02, 0xCF, 0xBB, 0x28, 0xD8, 0x74, 0xC2, 0x2C, + 0x24, 0x8B, 0xC5, 0xE2, 0x88, 0x39, 0x12, 0x9E, 0x50, 0x60, 0xF2, 0xA1, 0xFF, 0xFF, 0x12, 0xC0, + 0x69, 0x10, 0x78, 0x2C, 0x24, 0x2A, 0x07, 0xDB, 0xBB, 0xD4, 0xD6, 0x3B, 0xFF, 0xE8, 0x25, 0x83, + 0x09, 0x8A, 0x14, 0x15, 0x1A, 0x86, 0x84, 0xFB, 0x4A, 0xD5, 0x00, 0x80, 0x03, 0x0F, 0x30, 0x08, + 0x03, 0x39, 0xEE, 0x46, 0x30, 0x58, 0x02, 0x30, 0xA6, 0x1F, 0x32, 0x44, 0x56, 0x00, 0x8F, 0xE6, + 0x04, 0x4A, 0xA6, 0xCE, 0x12, 0x61, 0xCD, 0x27, 0x74, 0x98, 0x0A, 0x31, 0x32, 0xF7, 0x70, 0x34, + 0xE9, 0x86, 0xA5, 0x89, 0xBD, 0x8A, 0x80, 0x04, 0x1F, 0x34, 0xFF, 0xFB, 0x92, 0x64, 0x18, 0x0B, + 0x34, 0xAC, 0x34, 0x4B, 0xAB, 0xBB, 0xD1, 0xB0, 0x2F, 0x26, 0x69, 0x25, 0x00, 0xC7, 0x76, 0x92, + 0xC8, 0xD3, 0x2E, 0x0E, 0xF3, 0x44, 0x80, 0xBE, 0x19, 0xE5, 0xA0, 0x61, 0x96, 0x2A, 0x8E, 0xE1, + 0x2D, 0xA8, 0xAB, 0x5C, 0x07, 0xD7, 0x38, 0xF0, 0xF1, 0xA9, 0xE5, 0xBA, 0xDB, 0x8A, 0x0A, 0x43, + 0xD8, 0x28, 0x48, 0x05, 0x33, 0xB6, 0x56, 0x2D, 0x60, 0xD0, 0xF4, 0x6A, 0xDA, 0xC4, 0x38, 0xC1, + 0xDD, 0x94, 0x1C, 0x28, 0xEC, 0xC1, 0xD2, 0x15, 0x86, 0x0A, 0x38, 0x60, 0x0D, 0xB1, 0x83, 0x3C, + 0xA0, 0xCC, 0xF0, 0xB4, 0x64, 0x80, 0xC3, 0x81, 0x37, 0x0A, 0x66, 0x75, 0x23, 0x63, 0x11, 0x99, + 0x35, 0xCF, 0xBB, 0x4D, 0xB9, 0x8B, 0xDF, 0xDF, 0xFD, 0x61, 0x87, 0xC9, 0x2F, 0xFF, 0xD8, 0x5D, + 0x48, 0x1B, 0x40, 0x50, 0x8E, 0xC1, 0x54, 0x0D, 0x25, 0xA4, 0xD3, 0x90, 0xFE, 0xF5, 0x0A, 0xC1, + 0xF7, 0x54, 0x52, 0x90, 0x08, 0x00, 0x73, 0x4B, 0x2C, 0x18, 0x25, 0x5E, 0x42, 0x89, 0x26, 0x47, + 0x1D, 0x5C, 0xF1, 0x84, 0xC9, 0x0A, 0x46, 0x7F, 0xFD, 0x4F, 0x22, 0x40, 0xB0, 0xD8, 0xEB, 0x31, + 0xE2, 0x70, 0xEB, 0xEA, 0x6D, 0xFF, 0xFC, 0xE1, 0x71, 0xC6, 0x97, 0x34, 0x74, 0x49, 0x17, 0x79, + 0xE3, 0xE2, 0x5A, 0x95, 0x18, 0x06, 0x15, 0x9C, 0x11, 0xB2, 0x8D, 0x1B, 0x66, 0x08, 0x45, 0x26, + 0x5C, 0x0E, 0xC6, 0x05, 0x05, 0x1D, 0x6B, 0x40, 0x11, 0x5F, 0x0C, 0x38, 0x9C, 0xF0, 0x8A, 0x60, + 0x20, 0x28, 0xEC, 0x50, 0xD6, 0xE4, 0x36, 0x4F, 0x13, 0x65, 0x18, 0x34, 0x42, 0xD7, 0x7C, 0x2A, + 0x05, 0xBD, 0x02, 0x27, 0xC3, 0xA2, 0xC1, 0xBE, 0x26, 0x50, 0x2E, 0x69, 0x10, 0xA9, 0x16, 0x31, + 0x12, 0xB8, 0xDA, 0x36, 0xBB, 0x04, 0xA0, 0x5B, 0x82, 0x8A, 0x1A, 0xE8, 0x46, 0x34, 0x50, 0xA0, + 0x83, 0xC6, 0x1D, 0x77, 0x15, 0x11, 0x07, 0x1A, 0x6A, 0x60, 0xD2, 0x10, 0x00, 0x25, 0x42, 0x96, + 0xB7, 0xA6, 0x29, 0x2B, 0x61, 0x5F, 0x25, 0x01, 0xDE, 0x34, 0x80, 0x70, 0xE0, 0xD5, 0x18, 0x9D, + 0x19, 0x00, 0xCD, 0x26, 0xA0, 0xB9, 0xFD, 0xE3, 0xF9, 0x72, 0x82, 0x7F, 0xFF, 0x09, 0x24, 0x87, + 0x09, 0x25, 0xCC, 0x75, 0xD2, 0xA0, 0x38, 0xCA, 0xDB, 0x2D, 0xB5, 0x55, 0x0D, 0xA3, 0xC1, 0x81, + 0x6B, 0x5F, 0xD7, 0xE6, 0xFA, 0x81, 0xC3, 0x55, 0xBA, 0x08, 0x01, 0x03, 0xDF, 0xFF, 0x4C, 0x08, + 0x8B, 0xDF, 0xCC, 0x08, 0xC7, 0xB8, 0xE4, 0x07, 0x0C, 0x4F, 0xC7, 0x3F, 0xF0, 0x89, 0x45, 0xD1, + 0x60, 0xC5, 0x9C, 0x85, 0xD7, 0x7F, 0xD1, 0x3C, 0x10, 0xFE, 0x60, 0xC7, 0x77, 0x27, 0xFF, 0xCF, + 0xB7, 0xAB, 0xA6, 0xD9, 0xBE, 0x20, 0x2A, 0x80, 0xCA, 0x42, 0x68, 0x50, 0x4C, 0x33, 0x4F, 0x04, + 0x30, 0x5C, 0x20, 0x2A, 0x36, 0x27, 0x16, 0x0C, 0x86, 0x04, 0x00, 0x46, 0x97, 0x9F, 0xC6, 0x50, + 0x34, 0x64, 0x2A, 0xC6, 0x44, 0x3E, 0x62, 0x60, 0x26, 0x38, 0xA8, 0x61, 0xFF, 0xFB, 0x92, 0x64, + 0x11, 0x8A, 0x04, 0xA7, 0x34, 0x4C, 0x03, 0xBB, 0xD1, 0xB0, 0x33, 0x25, 0x09, 0xFA, 0x14, 0xC5, + 0x76, 0x90, 0xEC, 0xCF, 0x36, 0xEE, 0xF3, 0x42, 0x40, 0xCB, 0x0D, 0xA7, 0xB4, 0x53, 0x0D, 0xC0, + 0xA1, 0x80, 0x20, 0x63, 0xA8, 0x0D, 0x45, 0x00, 0x28, 0xE3, 0x8F, 0x30, 0xDB, 0x5E, 0x6E, 0x04, + 0xC0, 0x1B, 0xE6, 0x58, 0xF9, 0x3D, 0x68, 0x5D, 0xC7, 0x4D, 0xD9, 0x46, 0x71, 0x21, 0x53, 0xEB, + 0x07, 0x09, 0x6E, 0x24, 0x46, 0x14, 0x50, 0xCC, 0x9C, 0x2B, 0x24, 0x17, 0x2C, 0x76, 0x46, 0x3F, + 0xA2, 0x11, 0x12, 0xEC, 0x8B, 0x72, 0xBD, 0x8B, 0x24, 0x84, 0x2D, 0x50, 0x1A, 0x41, 0xCE, 0x14, + 0x18, 0x1C, 0xCD, 0xF3, 0x53, 0x37, 0x62, 0xBA, 0xCD, 0xA8, 0x23, 0x07, 0x5F, 0x36, 0x85, 0x47, + 0xFF, 0xAF, 0xF9, 0x24, 0x9F, 0x3D, 0x72, 0x82, 0x93, 0x0B, 0xB1, 0xBA, 0xEE, 0xD4, 0xB5, 0x7C, + 0xBB, 0xED, 0xD5, 0x86, 0xE4, 0xB0, 0x2C, 0x7F, 0x4D, 0xD7, 0x7A, 0x99, 0xEC, 0x35, 0xC7, 0x91, + 0x6B, 0xE2, 0x00, 0x45, 0x48, 0x00, 0x30, 0x20, 0x07, 0xF8, 0xC5, 0x82, 0x3E, 0x30, 0xB5, 0x24, + 0xA6, 0x23, 0x29, 0x67, 0x4E, 0x46, 0xF8, 0xE7, 0xA6, 0xFA, 0xCD, 0x92, 0x82, 0x8D, 0xA9, 0x88, + 0xA7, 0x73, 0xD5, 0xDD, 0x59, 0x74, 0xE4, 0x6E, 0x85, 0x6A, 0x02, 0x00, 0xC2, 0x47, 0x77, 0x27, + 0xF7, 0xFF, 0xDF, 0xFE, 0x18, 0x20, 0x18, 0x06, 0xC4, 0x3A, 0x0A, 0x99, 0x07, 0x0D, 0x98, 0x22, + 0x06, 0x98, 0xF0, 0x82, 0x7E, 0x41, 0xD1, 0x86, 0x84, 0xA6, 0x06, 0x82, 0x99, 0x00, 0xA6, 0x40, + 0x40, 0x68, 0x76, 0xCA, 0x4B, 0x38, 0xB4, 0x20, 0xD0, 0xE7, 0x20, 0xAC, 0x3E, 0x60, 0x43, 0xBB, + 0x4D, 0x21, 0xA7, 0x55, 0x61, 0x0A, 0xF6, 0x21, 0x07, 0xB7, 0xB1, 0x98, 0x5F, 0x64, 0x14, 0xAC, + 0x45, 0x5B, 0x2C, 0xAC, 0x03, 0x40, 0x98, 0x78, 0x66, 0x54, 0x48, 0x79, 0xA3, 0x20, 0x55, 0xB5, + 0x58, 0xD4, 0xAE, 0x61, 0xD0, 0x89, 0xA9, 0x90, 0x40, 0x78, 0x92, 0x5B, 0xB3, 0x66, 0x96, 0x5B, + 0xE8, 0xBB, 0x29, 0x6B, 0xF5, 0xA6, 0x7D, 0xBA, 0xE5, 0xD8, 0x76, 0xFF, 0xFE, 0xB7, 0x6F, 0x2B, + 0x7F, 0xF5, 0x7F, 0x2E, 0x50, 0xE1, 0x7D, 0xE1, 0xBD, 0x42, 0xFF, 0x50, 0xC7, 0xAD, 0xCF, 0x50, + 0x6A, 0xE5, 0xAF, 0x95, 0x58, 0xC6, 0x4D, 0x4B, 0x4A, 0x1C, 0xFF, 0xC3, 0x84, 0x70, 0x30, 0x09, + 0x00, 0x00, 0x20, 0x70, 0x06, 0xFB, 0x20, 0x6A, 0x9D, 0x9E, 0x81, 0xB8, 0x5D, 0xA0, 0x17, 0xCA, + 0x10, 0x43, 0xB3, 0x85, 0x1A, 0x86, 0x00, 0x72, 0xCC, 0x81, 0xB0, 0xD9, 0xC3, 0x02, 0xA4, 0xE2, + 0x96, 0x70, 0x92, 0xEE, 0x7E, 0x9A, 0xD5, 0xB8, 0xB2, 0xBE, 0xAF, 0xF8, 0xA2, 0xAD, 0xF6, 0xD5, + 0x44, 0x13, 0x03, 0xC3, 0x03, 0x63, 0x29, 0x63, 0x0C, 0xC1, 0xC1, 0x11, 0x7C, 0x70, 0x90, 0xFA, + 0x0C, 0x0D, 0x07, 0x88, 0x9B, 0x68, 0x29, 0x83, 0x11, 0x98, 0x00, 0x62, 0x8D, 0x00, 0xFF, 0xFB, + 0x92, 0x64, 0x0F, 0x0F, 0xF4, 0x6A, 0x34, 0xCC, 0x83, 0xBB, 0xC1, 0x40, 0x2E, 0xE3, 0xD9, 0xA8, + 0x04, 0xA3, 0x68, 0x12, 0x88, 0xD3, 0x2E, 0x0E, 0xEF, 0x26, 0xC0, 0xBD, 0x17, 0xE5, 0x00, 0x20, + 0x20, 0x28, 0x4C, 0x89, 0x89, 0x0C, 0x38, 0x68, 0xE1, 0x10, 0x9A, 0x61, 0x88, 0x0B, 0xAA, 0x16, + 0x10, 0xDF, 0x6D, 0x37, 0x97, 0xBC, 0x06, 0xBE, 0x5F, 0xB5, 0x87, 0x5D, 0x94, 0xCC, 0x68, 0xBA, + 0xEC, 0x15, 0x0F, 0xD8, 0x1A, 0x65, 0x24, 0x83, 0xF8, 0x10, 0x47, 0xE5, 0x06, 0x01, 0x07, 0x4E, + 0x80, 0xBC, 0x98, 0x24, 0xF3, 0x06, 0xB2, 0x8D, 0xC9, 0x50, 0x3C, 0x51, 0x12, 0xA3, 0x85, 0xE5, + 0xA7, 0x80, 0xC1, 0x8B, 0x4F, 0x38, 0xD3, 0x70, 0x95, 0xBA, 0x14, 0xF0, 0x4A, 0xA0, 0x94, 0x43, + 0x55, 0xAF, 0x7E, 0xB7, 0x4D, 0xF3, 0x7A, 0xD4, 0xF7, 0x66, 0x77, 0xF4, 0xB6, 0xAF, 0xC8, 0xF1, + 0xFB, 0x71, 0x29, 0x44, 0xA1, 0xB1, 0xE7, 0x6B, 0xF7, 0x4A, 0xF2, 0xF5, 0x94, 0xCE, 0x47, 0x97, + 0x5F, 0x0F, 0x0D, 0x00, 0x00, 0x01, 0x59, 0x09, 0x85, 0x9E, 0x27, 0x50, 0x96, 0x93, 0x32, 0xA5, + 0x84, 0xF4, 0x60, 0x54, 0x0E, 0xA8, 0x32, 0xD7, 0xAB, 0xA3, 0xBB, 0x0E, 0x75, 0xA4, 0xD7, 0x0E, + 0x08, 0x9A, 0x21, 0x4A, 0x56, 0x9A, 0x92, 0xCC, 0xD8, 0x22, 0x70, 0x68, 0x96, 0x44, 0xB1, 0x64, + 0x83, 0x81, 0xA1, 0x21, 0x60, 0xEB, 0x78, 0x8C, 0xC6, 0x60, 0xD4, 0xC0, 0x77, 0x00, 0xDB, 0xB4, + 0x54, 0x48, 0x14, 0x31, 0x5E, 0x04, 0x08, 0x8C, 0x35, 0x42, 0x83, 0xB2, 0x0D, 0x48, 0xC4, 0x13, + 0x8D, 0x16, 0x01, 0x5B, 0x0C, 0x11, 0xFE, 0x64, 0x04, 0x9C, 0x24, 0x8A, 0x04, 0x12, 0x3A, 0x99, + 0x6D, 0x87, 0x04, 0xCC, 0xC6, 0x81, 0x50, 0xA5, 0xD0, 0x16, 0x1D, 0xCA, 0x46, 0xD5, 0x5C, 0x5B, + 0xA0, 0x68, 0xCC, 0xE5, 0x2F, 0x45, 0x0D, 0x74, 0x99, 0x83, 0x9B, 0x36, 0x1E, 0xF4, 0x7C, 0x2A, + 0x82, 0x14, 0xCD, 0xA4, 0xFC, 0x4C, 0x50, 0x82, 0xEA, 0xB3, 0x03, 0x14, 0x95, 0x98, 0x0E, 0x0A, + 0x08, 0x7D, 0x10, 0x90, 0x4D, 0x1D, 0xE4, 0x19, 0x7F, 0xD3, 0xDA, 0x92, 0xF3, 0x0F, 0x93, 0x5F, + 0x58, 0xF7, 0xFF, 0xF5, 0x31, 0xCB, 0x32, 0xFD, 0xD1, 0x73, 0x52, 0xCE, 0xC1, 0x54, 0x74, 0x32, + 0x0B, 0x3A, 0x51, 0x9F, 0x4B, 0xD9, 0x14, 0x89, 0xF8, 0xDE, 0xB1, 0x94, 0xB6, 0x7A, 0x68, 0xC3, + 0x53, 0x78, 0x19, 0xC6, 0x61, 0xB8, 0xD1, 0x5B, 0xF1, 0xA0, 0xAE, 0x55, 0x50, 0xA3, 0xBD, 0x87, + 0x8C, 0x38, 0xE8, 0x18, 0x10, 0x45, 0xFE, 0xDB, 0x43, 0x1D, 0xCD, 0x14, 0x6E, 0xB2, 0xB4, 0x7A, + 0xF1, 0x78, 0xB5, 0xFF, 0x9B, 0xFC, 0x35, 0x9A, 0xDF, 0x8D, 0x16, 0xB1, 0x71, 0x11, 0x16, 0xB1, + 0x5B, 0xC5, 0x20, 0xD2, 0x55, 0x03, 0x0A, 0xC0, 0xE3, 0x84, 0x07, 0xD2, 0x63, 0x1C, 0x44, 0x1F, + 0x1E, 0x4A, 0x08, 0x06, 0x09, 0x13, 0x28, 0x1F, 0x02, 0xD1, 0x89, 0x20, 0x07, 0x67, 0x85, 0xC4, + 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0xF4, 0x6A, 0x34, 0xCC, 0x83, 0xBB, 0xC9, 0x30, 0x31, 0x65, + 0xF8, 0xD0, 0x00, 0x2D, 0x60, 0x11, 0xBC, 0xD5, 0x32, 0x0E, 0xEB, 0x06, 0x40, 0xC5, 0x16, 0xE3, + 0x40, 0x03, 0x34, 0x91, 0x4C, 0x74, 0x5C, 0xC2, 0x8A, 0x44, 0x69, 0xC6, 0xBA, 0x88, 0x1E, 0x67, + 0x1C, 0xAF, 0xD9, 0x92, 0x15, 0x58, 0x70, 0x15, 0x82, 0x53, 0x82, 0x59, 0x68, 0x46, 0x23, 0xA4, + 0xDD, 0x54, 0x9C, 0xC2, 0xCF, 0x48, 0xC5, 0xAC, 0x18, 0x33, 0x64, 0x4A, 0xE6, 0xAC, 0xCC, 0xC1, + 0x5E, 0xBA, 0xE4, 0x81, 0x21, 0x5D, 0x3B, 0x18, 0x9C, 0x55, 0x61, 0xB2, 0x92, 0xAC, 0xB0, 0xAB, + 0x6E, 0x8F, 0xAA, 0xFD, 0xDF, 0x5C, 0xC5, 0x62, 0xE8, 0x64, 0x88, 0xEC, 0x3C, 0x81, 0x3A, 0xEF, + 0x8D, 0x1D, 0x0B, 0xB1, 0xFF, 0xFF, 0x25, 0xE6, 0x3A, 0xED, 0x06, 0x56, 0x65, 0x7F, 0x41, 0xAD, + 0xB3, 0xFD, 0x49, 0x5A, 0x9D, 0x3B, 0xFA, 0xDF, 0x54, 0x73, 0x6F, 0x4F, 0xE3, 0xB8, 0xE5, 0xAA, + 0x66, 0xF9, 0xE8, 0x62, 0x76, 0x26, 0x1E, 0x21, 0xC5, 0x43, 0xF5, 0x07, 0x67, 0x4B, 0x44, 0x39, + 0x26, 0x87, 0xE6, 0x02, 0x18, 0x2A, 0x77, 0xFD, 0x4F, 0xEA, 0xF4, 0x54, 0x3B, 0x41, 0x3B, 0x12, + 0xB6, 0x40, 0x7D, 0x33, 0x5F, 0x58, 0xD4, 0x2B, 0xBD, 0x54, 0x94, 0xFC, 0x9A, 0x4A, 0x98, 0x97, + 0x48, 0x85, 0x8A, 0x52, 0x89, 0x62, 0x93, 0x3F, 0x30, 0x40, 0x28, 0x37, 0x9E, 0x3E, 0x32, 0x18, + 0x38, 0x32, 0x35, 0xAF, 0x36, 0x64, 0xC4, 0x31, 0x1C, 0x17, 0x32, 0x35, 0xA5, 0x34, 0x89, 0xCD, + 0x02, 0x53, 0x75, 0x38, 0xA0, 0xAA, 0x44, 0x18, 0x28, 0x08, 0x40, 0xAE, 0xA5, 0x20, 0x1D, 0x29, + 0x73, 0xD4, 0xE4, 0x43, 0xAF, 0xB3, 0x71, 0xDA, 0xA8, 0x31, 0xF9, 0x92, 0xE7, 0xD0, 0x2A, 0x75, + 0xE0, 0xBB, 0x0A, 0xAF, 0x5F, 0x4D, 0x61, 0x93, 0xBC, 0x49, 0x8E, 0xF6, 0xA8, 0xD8, 0x1A, 0xD2, + 0x32, 0x09, 0x02, 0xD7, 0x06, 0xAA, 0x39, 0x6A, 0xFB, 0x00, 0x89, 0x5F, 0xAD, 0x15, 0x11, 0x5C, + 0xC1, 0xC0, 0x86, 0x9F, 0x72, 0x25, 0x4C, 0x8C, 0x9D, 0xF4, 0x91, 0x0F, 0x2E, 0xEA, 0xF0, 0xCB, + 0x1E, 0xDE, 0xFF, 0xC6, 0x96, 0xFD, 0x78, 0xA6, 0x9F, 0x4E, 0xD7, 0xA6, 0xE4, 0x73, 0xFD, 0xD0, + 0xBE, 0xC2, 0xE4, 0x54, 0x2E, 0x54, 0x22, 0x38, 0xE3, 0xEA, 0x33, 0x6F, 0xE0, 0x9C, 0x64, 0xB1, + 0x67, 0x7E, 0x3F, 0x3F, 0xCF, 0x12, 0x10, 0xFA, 0x87, 0xF8, 0xC5, 0x13, 0x14, 0x37, 0x7A, 0x96, + 0xEE, 0x4D, 0x19, 0x62, 0x78, 0x03, 0x20, 0x58, 0x13, 0x92, 0x44, 0xDD, 0x4C, 0xF5, 0x7F, 0xFA, + 0x93, 0x0F, 0x00, 0xCC, 0x80, 0xB5, 0x66, 0x5E, 0xB3, 0x01, 0xBC, 0xFA, 0x92, 0x3A, 0x30, 0x6F, + 0xFE, 0xB2, 0xE9, 0xA2, 0x5D, 0x9A, 0x63, 0x43, 0x81, 0xA9, 0xA9, 0x17, 0xF9, 0x81, 0x80, 0x79, + 0x8B, 0x8D, 0x69, 0xC1, 0xC7, 0xA1, 0x83, 0x82, 0x09, 0xA0, 0x01, 0xB8, 0xF2, 0x86, 0xCB, 0x4C, + 0x2C, 0x1C, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x74, 0x6E, 0x34, 0xCC, 0x83, 0xBA, 0x7A, 0xF0, + 0x32, 0x66, 0x59, 0x65, 0x1D, 0x22, 0x94, 0xD1, 0x48, 0xD3, 0x34, 0x0E, 0xE9, 0xEB, 0xC0, 0xB5, + 0x17, 0xE6, 0xA0, 0xA3, 0x0A, 0x18, 0x44, 0x81, 0x61, 0x1A, 0xD3, 0x20, 0x1C, 0x0C, 0x58, 0xE0, + 0x29, 0x90, 0x2B, 0x32, 0xB4, 0x2E, 0x68, 0x06, 0x92, 0x5E, 0x44, 0x1D, 0xDB, 0x7E, 0xAB, 0x3B, + 0xE5, 0xC8, 0xC0, 0x60, 0x0B, 0x51, 0x4C, 0x72, 0xF2, 0x2E, 0x64, 0x8A, 0x0C, 0x19, 0x52, 0x01, + 0x89, 0xBF, 0xA0, 0x28, 0xB2, 0xB2, 0x13, 0x45, 0x69, 0xD7, 0x8A, 0x18, 0xF5, 0xFD, 0x1E, 0x08, + 0x48, 0x10, 0x40, 0x52, 0x79, 0x64, 0xAA, 0x99, 0x71, 0x18, 0x00, 0x8B, 0xA8, 0x0A, 0x03, 0xD8, + 0x2F, 0xC7, 0x92, 0xB0, 0x81, 0x34, 0x2E, 0xDA, 0x7F, 0xF5, 0x85, 0x35, 0x1A, 0x34, 0xB7, 0x35, + 0x19, 0x74, 0xDD, 0x56, 0xA3, 0x96, 0x84, 0x6E, 0x96, 0x31, 0x99, 0xD4, 0xE8, 0x75, 0x97, 0xB7, + 0x94, 0xF6, 0x8F, 0x76, 0x97, 0x82, 0x69, 0x18, 0x40, 0x00, 0x0A, 0xFF, 0x40, 0x26, 0x05, 0x1A, + 0x7F, 0xEB, 0xDC, 0xF7, 0xF6, 0xDC, 0xEE, 0xBF, 0x12, 0x9C, 0x6F, 0x6B, 0x01, 0x71, 0x39, 0x39, + 0x1B, 0x6A, 0x8C, 0x85, 0x7D, 0x12, 0x1C, 0xEE, 0x1D, 0xC3, 0x0E, 0x8D, 0x41, 0x1D, 0x09, 0x25, + 0x4D, 0xFA, 0xEA, 0x75, 0x00, 0x60, 0xE3, 0xFE, 0x11, 0xD3, 0x92, 0x81, 0x26, 0x03, 0x87, 0xC6, + 0x40, 0x57, 0x06, 0x13, 0x04, 0xC1, 0x84, 0x01, 0xD7, 0x00, 0xD8, 0xD0, 0xE8, 0x64, 0xCA, 0x34, + 0xA6, 0x21, 0xC1, 0xC1, 0x8E, 0xA1, 0x10, 0x18, 0x23, 0x02, 0x1B, 0x00, 0x89, 0x2C, 0x31, 0x23, + 0xD4, 0x98, 0x41, 0x40, 0x64, 0x45, 0x17, 0x4C, 0x6A, 0xB3, 0xD2, 0xA6, 0x10, 0x4A, 0xD0, 0x96, + 0x43, 0x85, 0xCB, 0xC9, 0xEB, 0x4D, 0x47, 0x5C, 0xBF, 0x4D, 0x01, 0x97, 0xA3, 0xEB, 0x86, 0xAC, + 0x0A, 0xD7, 0x04, 0x09, 0x37, 0x62, 0xE5, 0x80, 0x85, 0x18, 0x99, 0xF9, 0x7B, 0xA9, 0x53, 0xF0, + 0x69, 0x6C, 0x0A, 0x4A, 0x21, 0x70, 0xC3, 0x84, 0x40, 0x90, 0xE1, 0x90, 0x35, 0xAA, 0x0B, 0x37, + 0x20, 0x49, 0x93, 0x49, 0x4C, 0x3A, 0xA6, 0x71, 0xFE, 0x32, 0xC3, 0x34, 0x91, 0x73, 0x17, 0xC9, + 0xAE, 0xFF, 0xE0, 0xD2, 0xE1, 0x4F, 0x9B, 0x20, 0x39, 0xF2, 0x81, 0xDC, 0x1D, 0x61, 0x19, 0xB4, + 0x8A, 0x5F, 0x44, 0xBE, 0x80, 0x60, 0x6B, 0xFD, 0x04, 0x00, 0x66, 0x5C, 0x4B, 0x2F, 0xFD, 0xF3, + 0x1E, 0x3F, 0x9A, 0x63, 0x90, 0x6A, 0x6B, 0xB8, 0x44, 0x4B, 0x87, 0x10, 0x78, 0x34, 0x06, 0xE2, + 0xBC, 0xB2, 0x92, 0x8E, 0x84, 0x54, 0x64, 0x3F, 0x45, 0xF6, 0xFB, 0x70, 0x63, 0xDD, 0xA3, 0xF4, + 0x34, 0xCD, 0x2F, 0x31, 0x82, 0xC2, 0x19, 0xC3, 0x79, 0x19, 0x87, 0xC2, 0x28, 0x15, 0xFC, 0x34, + 0xD8, 0xF7, 0x14, 0x24, 0x33, 0x1D, 0xE3, 0xD4, 0x54, 0x31, 0xC1, 0x43, 0x68, 0x5A, 0x02, 0x0B, + 0x85, 0x5C, 0x57, 0x60, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x14, 0x8F, 0x34, 0xCC, 0x03, 0xBB, + 0xC9, 0x30, 0x2E, 0xC3, 0xC9, 0xB8, 0x1C, 0x43, 0x4A, 0x11, 0x9C, 0xD3, 0x32, 0x0E, 0xEB, 0x26, + 0x80, 0xC3, 0x17, 0x66, 0x60, 0x23, 0x0B, 0x02, 0x5A, 0x3C, 0x14, 0xA2, 0x11, 0x05, 0xDA, 0x16, + 0xE1, 0xAF, 0x45, 0x68, 0xA2, 0x88, 0xFB, 0x4A, 0xAD, 0xB0, 0x73, 0x5A, 0x2A, 0x05, 0x7D, 0xFD, + 0x12, 0x15, 0x82, 0x08, 0x15, 0x81, 0xD0, 0xCD, 0x63, 0xAF, 0x15, 0xF1, 0x22, 0x6E, 0xA6, 0x41, + 0x95, 0xC8, 0x3A, 0x1B, 0x9D, 0x3B, 0x51, 0x95, 0xD5, 0x18, 0x70, 0x38, 0xC4, 0x99, 0x24, 0x95, + 0x2F, 0x44, 0x60, 0x04, 0x08, 0xD7, 0x09, 0x10, 0x8B, 0x60, 0x14, 0x12, 0x7C, 0x80, 0x51, 0xA1, + 0x63, 0x8B, 0xA6, 0x45, 0x11, 0x84, 0xFF, 0xFE, 0xF3, 0x94, 0xD0, 0x4E, 0x7D, 0x37, 0xE5, 0x6F, + 0x77, 0xB3, 0x92, 0x26, 0x6D, 0x94, 0x3A, 0xC2, 0xAC, 0xB1, 0x28, 0xE3, 0xBA, 0xBD, 0x31, 0xFD, + 0xC1, 0x5F, 0x0B, 0x98, 0x83, 0xF6, 0xC1, 0x38, 0x04, 0x08, 0x00, 0x40, 0x25, 0x7E, 0x84, 0x81, + 0x70, 0xE1, 0x49, 0xFE, 0x67, 0xBB, 0x60, 0xE7, 0x0A, 0xD5, 0xC8, 0x13, 0x89, 0xA4, 0xB0, 0xD4, + 0x20, 0x18, 0x13, 0xAF, 0x40, 0xC5, 0x87, 0x38, 0x78, 0x31, 0xCF, 0x24, 0x24, 0xA8, 0x5F, 0xE2, + 0x52, 0xAC, 0x02, 0x88, 0xAB, 0x37, 0x52, 0x10, 0x17, 0xC8, 0xE4, 0x66, 0xA8, 0x04, 0x55, 0x83, + 0x17, 0x63, 0xA3, 0xC8, 0xF3, 0x0B, 0x45, 0x13, 0x32, 0x51, 0x70, 0x5B, 0x93, 0x16, 0x80, 0xCE, + 0x4B, 0x30, 0x01, 0xCC, 0xD8, 0x24, 0x6C, 0x31, 0x52, 0x4C, 0x83, 0x20, 0x80, 0xE3, 0x47, 0x95, + 0xA0, 0x76, 0xF6, 0xF4, 0x2A, 0x79, 0x7B, 0x19, 0x71, 0x2C, 0x31, 0x9F, 0x95, 0x31, 0x54, 0xF2, + 0x20, 0x29, 0x71, 0x37, 0x10, 0x70, 0x51, 0x25, 0x0E, 0x64, 0x8D, 0xC0, 0x40, 0xDA, 0xD4, 0x25, + 0x38, 0x6E, 0x36, 0x7A, 0x30, 0x23, 0xB2, 0x5B, 0xA2, 0x6D, 0xD9, 0xE8, 0x58, 0x15, 0x9E, 0xFB, + 0x25, 0x6B, 0x25, 0x4A, 0xA7, 0xCA, 0xE0, 0xA9, 0xED, 0x4D, 0xA2, 0x84, 0x29, 0x0F, 0x2D, 0x2D, + 0xD3, 0xDE, 0xFF, 0xFE, 0xD8, 0xC6, 0x9A, 0xEE, 0xA5, 0xBD, 0xA9, 0x6B, 0xFB, 0xD8, 0xF3, 0x1E, + 0xC1, 0x7C, 0xAD, 0x7B, 0x4E, 0x0D, 0x98, 0xC2, 0xCD, 0xBD, 0x9F, 0x6B, 0x3A, 0xF2, 0x77, 0x4A, + 0x45, 0xA5, 0x77, 0xA0, 0x08, 0x00, 0x00, 0x66, 0xE1, 0x00, 0x1A, 0x54, 0x23, 0x50, 0x00, 0x63, + 0xB5, 0x51, 0xF0, 0x2F, 0x50, 0x02, 0x0E, 0x34, 0x62, 0x35, 0x93, 0x87, 0x15, 0xAC, 0xF6, 0x28, + 0xC4, 0x16, 0x47, 0x15, 0x53, 0x04, 0xEA, 0xAD, 0xD0, 0xB3, 0x1F, 0xF4, 0x64, 0x09, 0x9E, 0x50, + 0x7D, 0x00, 0x47, 0x06, 0x15, 0x5C, 0x46, 0x08, 0x04, 0x47, 0x49, 0x94, 0x46, 0x56, 0x11, 0x06, + 0x4F, 0x9A, 0xE7, 0xA7, 0x93, 0x86, 0x2F, 0x90, 0x26, 0x7E, 0x2C, 0xE6, 0x49, 0x87, 0xA6, 0x0E, + 0x8B, 0x27, 0x9E, 0x50, 0xD0, 0xB3, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8F, 0x04, 0xAA, 0x34, 0xCC, + 0x03, 0xBA, 0xCA, 0x70, 0x2E, 0x44, 0x29, 0xC4, 0x14, 0xC3, 0xA2, 0x11, 0xE0, 0xD1, 0x30, 0x0E, + 0xEF, 0x25, 0x08, 0xC8, 0x1E, 0xA9, 0x34, 0x50, 0xAA, 0x9A, 0x11, 0x7C, 0xA2, 0x99, 0x95, 0x76, + 0x6E, 0x9A, 0xA6, 0x11, 0x81, 0x48, 0x24, 0x36, 0x9A, 0x05, 0x91, 0xC3, 0x08, 0x70, 0xE2, 0x8F, + 0xAB, 0x4C, 0x00, 0x55, 0x01, 0x2D, 0x80, 0x11, 0xF1, 0x0B, 0x82, 0xA1, 0x81, 0xC3, 0x25, 0x48, + 0x01, 0x65, 0x0E, 0x32, 0xB0, 0x36, 0x40, 0x6A, 0x84, 0xE0, 0x59, 0xE4, 0x64, 0x9B, 0xA1, 0x00, + 0x42, 0xC2, 0x30, 0x00, 0x6F, 0x80, 0x28, 0x0B, 0x74, 0x6F, 0x8A, 0xE8, 0x88, 0xCC, 0x1A, 0x22, + 0x3D, 0x56, 0xDB, 0xBA, 0x44, 0x1C, 0x84, 0x08, 0x2C, 0x9D, 0x7C, 0xA4, 0x86, 0x3C, 0xFF, 0xFE, + 0xCA, 0xA5, 0x1D, 0xFC, 0xB2, 0xEE, 0xBB, 0xFF, 0x85, 0x36, 0xED, 0xD2, 0x2E, 0xCA, 0x8E, 0x93, + 0x4F, 0x75, 0xB1, 0xD7, 0xC3, 0x95, 0x26, 0xDD, 0x48, 0x22, 0x2D, 0x0E, 0xB7, 0x6C, 0xC3, 0x02, + 0x80, 0x00, 0x06, 0x7A, 0xC6, 0x07, 0x75, 0x85, 0x36, 0x03, 0x8A, 0x9D, 0x6B, 0xAB, 0x15, 0xDD, + 0x67, 0xB9, 0x6B, 0xC2, 0xB2, 0x6B, 0xDD, 0x04, 0x7F, 0xF0, 0xF4, 0x52, 0x8C, 0x60, 0xD7, 0xB1, + 0xA2, 0x95, 0x09, 0xD3, 0xE5, 0xEB, 0x0C, 0x04, 0x81, 0x3D, 0xE4, 0x96, 0xE0, 0x40, 0x06, 0x0D, + 0x09, 0xCD, 0x4C, 0xA8, 0xC2, 0x12, 0x23, 0x18, 0x99, 0x33, 0x56, 0x94, 0xA3, 0x1E, 0x71, 0x0A, + 0x8F, 0x1F, 0x49, 0x89, 0x8C, 0x10, 0x9E, 0xF0, 0xCA, 0x74, 0x32, 0xD8, 0xB1, 0xA3, 0x14, 0x99, + 0x92, 0x84, 0xB4, 0x80, 0x30, 0x79, 0x3A, 0x72, 0x10, 0xA5, 0x8D, 0x50, 0xB8, 0xB5, 0x99, 0x48, + 0xF0, 0x12, 0xA9, 0x5B, 0xE5, 0x69, 0x49, 0xCA, 0x1B, 0x18, 0xD6, 0xB3, 0xA2, 0x32, 0x15, 0xE2, + 0x17, 0x17, 0x9E, 0x03, 0x15, 0x38, 0x1D, 0x62, 0xCB, 0x39, 0x00, 0x4F, 0x51, 0xC2, 0x8B, 0x20, + 0x91, 0xC2, 0x1E, 0x46, 0xA5, 0x42, 0x78, 0xA0, 0x08, 0x82, 0x96, 0xC5, 0x18, 0xAB, 0x0D, 0xAB, + 0x0E, 0x38, 0xF0, 0xD0, 0xD0, 0xA3, 0x10, 0xCB, 0x22, 0x5D, 0x3F, 0x8F, 0xFE, 0x5A, 0xFA, 0x3E, + 0xFF, 0xFF, 0xFF, 0xFF, 0xCA, 0xE4, 0x17, 0x63, 0x91, 0x28, 0x02, 0x86, 0x34, 0x94, 0x92, 0xE7, + 0x8A, 0xF6, 0x12, 0x7F, 0xC5, 0x77, 0xC7, 0x1E, 0x89, 0xC9, 0x68, 0xB2, 0x80, 0x80, 0x04, 0x11, + 0x00, 0x52, 0xF0, 0x09, 0xA1, 0x10, 0xEE, 0xDA, 0x36, 0x5B, 0x31, 0x96, 0x9C, 0x1C, 0xD9, 0x5E, + 0xE4, 0xEB, 0x7F, 0x81, 0x99, 0xCC, 0x5E, 0x73, 0xFF, 0x88, 0xE0, 0x70, 0xFB, 0xFF, 0xFE, 0x9F, + 0xF7, 0x63, 0x3F, 0xFF, 0xB9, 0x47, 0x71, 0x01, 0x60, 0x78, 0xA2, 0x39, 0xF1, 0x55, 0x00, 0x00, + 0x07, 0x01, 0x1D, 0xC7, 0x42, 0xA3, 0x09, 0x27, 0xC3, 0x0A, 0x81, 0x03, 0x1E, 0x86, 0x43, 0xA7, + 0x00, 0x51, 0xA2, 0x00, 0xC4, 0xA3, 0x08, 0xC6, 0xFF, 0xFB, 0x92, 0x64, 0x0D, 0x0E, 0x04, 0x55, + 0x34, 0x4D, 0x9B, 0xB8, 0x4B, 0xE0, 0x33, 0x83, 0xD9, 0xDA, 0x24, 0x43, 0x3A, 0x11, 0x30, 0xD3, + 0x34, 0x4E, 0xE4, 0xEF, 0x90, 0xC9, 0x8C, 0xE8, 0x74, 0x80, 0x89, 0xE2, 0x30, 0x3C, 0x60, 0x1F, + 0x31, 0x1C, 0x0C, 0x49, 0x42, 0xA8, 0x2A, 0x28, 0x00, 0x18, 0x04, 0x03, 0x8D, 0x18, 0x89, 0x60, + 0xD2, 0x9E, 0x6A, 0x48, 0x72, 0x86, 0x03, 0x5C, 0x93, 0x4F, 0xA3, 0x71, 0x81, 0xDD, 0xB9, 0xDC, + 0xDA, 0x86, 0x51, 0x84, 0xE8, 0x86, 0x05, 0x4E, 0xFC, 0xB1, 0x25, 0x4D, 0x47, 0x00, 0x0B, 0xE1, + 0x9E, 0x09, 0x09, 0x9B, 0x2B, 0x32, 0xB1, 0x37, 0x02, 0xA3, 0x48, 0xBE, 0xB5, 0x93, 0x45, 0x93, + 0x42, 0x89, 0xC1, 0x07, 0xDF, 0xCD, 0xB2, 0xCA, 0x38, 0xAA, 0x4F, 0x74, 0xC4, 0xD7, 0xFF, 0xFE, + 0x5C, 0xBE, 0x7F, 0xFF, 0xF3, 0x2A, 0xEB, 0x14, 0xAC, 0x7C, 0x7B, 0x04, 0xA3, 0x88, 0x5D, 0xD0, + 0xCD, 0x69, 0x23, 0xB4, 0xC8, 0xFF, 0xEA, 0xAD, 0x85, 0x4B, 0xAD, 0xF1, 0x18, 0x04, 0x48, 0x00, + 0x00, 0x40, 0xE0, 0x2D, 0xBE, 0x84, 0x46, 0x09, 0x98, 0x6C, 0x32, 0xEF, 0xD5, 0xE0, 0xC3, 0xE5, + 0xB7, 0x07, 0xF5, 0x08, 0x80, 0x23, 0x08, 0xE8, 0x40, 0x70, 0x43, 0xB8, 0x40, 0xC8, 0xA1, 0x63, + 0x09, 0xCF, 0x82, 0x14, 0x35, 0xBD, 0x9F, 0xEE, 0xF4, 0x7F, 0xAE, 0x93, 0xC8, 0xA5, 0x5A, 0xC8, + 0x06, 0x06, 0x01, 0x80, 0xC0, 0x00, 0x20, 0xD0, 0x98, 0xA4, 0xC8, 0x20, 0xEC, 0xC3, 0xF4, 0xD8, + 0xCC, 0x75, 0x44, 0xC0, 0xF0, 0xC8, 0xC2, 0x43, 0x49, 0xD0, 0x30, 0x48, 0x08, 0x30, 0xE0, 0x45, + 0x6E, 0xA1, 0x60, 0x44, 0x20, 0x24, 0x00, 0x8B, 0x86, 0x1E, 0x08, 0x32, 0x85, 0xF0, 0xB5, 0xDA, + 0x32, 0xC3, 0x39, 0xEC, 0xF3, 0x08, 0x02, 0x09, 0x4D, 0x67, 0x8A, 0x5B, 0x5E, 0x56, 0xD4, 0xF3, + 0x86, 0x8B, 0xF4, 0xDA, 0x8C, 0x16, 0xDB, 0xB6, 0x25, 0x23, 0x2E, 0x14, 0x10, 0x4D, 0x59, 0xC1, + 0x96, 0xDE, 0x49, 0x96, 0x15, 0x4E, 0x22, 0x24, 0x6C, 0x65, 0x86, 0x10, 0x14, 0xED, 0x08, 0x82, + 0x1D, 0x06, 0xD6, 0x35, 0xF1, 0x58, 0x79, 0x98, 0xE2, 0xF4, 0xAA, 0xB9, 0xFA, 0xFC, 0x9B, 0xE5, + 0x1B, 0xE5, 0x4D, 0x2C, 0x80, 0xF4, 0x23, 0x0F, 0x1A, 0x40, 0x60, 0x32, 0xD1, 0xE7, 0x10, 0xB8, + 0xC9, 0x82, 0x40, 0x8C, 0x43, 0xFE, 0x1D, 0xEF, 0xE9, 0x43, 0x00, 0x34, 0xA1, 0x24, 0x00, 0x12, + 0x54, 0x0A, 0x11, 0xB2, 0xDC, 0xD9, 0x5A, 0xFA, 0x6F, 0xC6, 0x82, 0xA6, 0x10, 0x37, 0x4C, 0x55, + 0x2E, 0xA0, 0x9B, 0x21, 0xE3, 0xEB, 0x12, 0x75, 0xCC, 0xEF, 0xE4, 0xAD, 0xE5, 0x40, 0xE6, 0xD2, + 0x5B, 0xA1, 0xA8, 0xFF, 0x06, 0xE9, 0x42, 0x90, 0xD6, 0x02, 0x48, 0x9E, 0x00, 0x03, 0x04, 0xE9, + 0x30, 0x2C, 0x62, 0x36, 0xE0, 0x08, 0x28, 0x42, 0x8C, 0x3F, 0x22, 0xCF, 0x85, 0x1F, 0x8C, 0x53, + 0x09, 0x8C, 0x71, 0x42, 0x0E, 0xE0, 0x53, 0x28, 0x0C, 0xF6, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0F, + 0x04, 0x7B, 0x34, 0x4C, 0x93, 0xBA, 0xC1, 0xB4, 0x2F, 0xE6, 0x8A, 0x1D, 0x14, 0x28, 0x8E, 0x92, + 0x64, 0xD1, 0x30, 0x0E, 0xEF, 0x44, 0x80, 0xB6, 0x16, 0xE4, 0xC0, 0x30, 0x2C, 0x98, 0xE6, 0x7F, + 0xCC, 0x38, 0x20, 0xC3, 0x86, 0x01, 0x50, 0x0E, 0x39, 0x30, 0xAA, 0xE2, 0x4E, 0x80, 0xA1, 0x51, + 0x69, 0x5B, 0x83, 0x4C, 0xFA, 0xC3, 0x54, 0x0B, 0xD6, 0x15, 0x3A, 0xA8, 0x26, 0xDD, 0xB4, 0xE2, + 0x4E, 0x31, 0x64, 0x29, 0x35, 0x83, 0x12, 0xDB, 0xA8, 0x33, 0xE0, 0xFC, 0xB3, 0xE0, 0xD4, 0x2D, + 0x5A, 0x12, 0x2A, 0x10, 0x90, 0x05, 0x14, 0x2F, 0x78, 0xCB, 0x6E, 0xE8, 0x21, 0x28, 0x17, 0x69, + 0x1C, 0x1D, 0x63, 0x24, 0x88, 0x81, 0xDD, 0x01, 0xA2, 0xC2, 0xD9, 0x4C, 0x9F, 0xFF, 0xFF, 0x0E, + 0x7F, 0xD6, 0xE7, 0xFF, 0xFF, 0xCD, 0xE7, 0x21, 0xA9, 0x21, 0xF9, 0x14, 0xA6, 0x0B, 0xAF, 0x21, + 0xEF, 0x3F, 0xF7, 0xB9, 0x8E, 0x7B, 0xE6, 0xE5, 0x9D, 0xFD, 0x3D, 0xFD, 0xAA, 0x3C, 0x35, 0x0C, + 0x00, 0x28, 0x68, 0xA0, 0x00, 0x46, 0x50, 0x01, 0x9E, 0x22, 0x22, 0xDE, 0x8F, 0xE3, 0x40, 0x41, + 0xE2, 0xA8, 0x74, 0xFB, 0x09, 0x2C, 0xFB, 0x21, 0x09, 0xEB, 0x34, 0x7C, 0xE1, 0x5C, 0xF1, 0xCF, + 0xFE, 0x7F, 0xCF, 0x94, 0xBF, 0xF6, 0xDC, 0x28, 0xEE, 0xFF, 0x14, 0xB9, 0x36, 0x31, 0x1A, 0x59, + 0x88, 0x20, 0x02, 0x39, 0x26, 0x5C, 0x30, 0xB0, 0x44, 0x30, 0x4E, 0x61, 0x31, 0x7D, 0x44, 0x31, + 0xD3, 0xD3, 0x2F, 0xCD, 0x0E, 0xF9, 0x31, 0x41, 0xB3, 0xD8, 0x2F, 0x1A, 0x15, 0x0A, 0x1B, 0x38, + 0x8A, 0xCC, 0xAC, 0xE3, 0xE2, 0xD2, 0x20, 0x60, 0x00, 0x89, 0x00, 0x95, 0xC3, 0x3B, 0x80, 0xD0, + 0xBE, 0x26, 0x5E, 0xF7, 0xB6, 0x54, 0xB4, 0x2D, 0x27, 0x62, 0xA1, 0xCD, 0x1F, 0x16, 0x7C, 0x50, + 0x32, 0x13, 0x20, 0x2C, 0x8A, 0x11, 0x36, 0xC6, 0x26, 0x88, 0xD1, 0x42, 0x02, 0xC5, 0x02, 0xDC, + 0x33, 0x0E, 0x25, 0x65, 0x15, 0x02, 0x93, 0x4A, 0x0B, 0x88, 0x0A, 0x00, 0x0C, 0x44, 0x9D, 0x40, + 0xA0, 0x55, 0xD5, 0x38, 0xD0, 0x3A, 0x61, 0xC0, 0xEE, 0x6A, 0xA9, 0x98, 0x10, 0x51, 0xD2, 0xD4, + 0x33, 0xA8, 0x1A, 0xF7, 0xFF, 0xEB, 0x3B, 0xFF, 0x8F, 0xEF, 0xB8, 0x6F, 0x94, 0xB3, 0x31, 0x15, + 0xD7, 0x49, 0x5A, 0x15, 0xA8, 0xD3, 0x09, 0x7E, 0x27, 0xF9, 0xFF, 0xF8, 0xCF, 0x40, 0xB3, 0xF0, + 0x2C, 0x79, 0x34, 0xA0, 0x13, 0xAE, 0xD0, 0xD4, 0xD6, 0xBA, 0x73, 0xA3, 0x45, 0xF2, 0x9D, 0x44, + 0x3A, 0xE2, 0x09, 0xA9, 0x1E, 0xEB, 0xFD, 0xB4, 0x91, 0xEB, 0xDC, 0xEF, 0x8B, 0xFF, 0x52, 0x5E, + 0xBA, 0x87, 0x3F, 0xE1, 0x6E, 0xE1, 0x9C, 0x1C, 0xFF, 0x73, 0x8E, 0xC1, 0x72, 0xA7, 0x7C, 0x4A, + 0x58, 0x43, 0x06, 0x45, 0x33, 0x64, 0xB4, 0xF3, 0x12, 0xC1, 0x73, 0x12, 0x97, 0x53, 0xD3, 0x05, + 0xE1, 0xA1, 0xE0, 0xC0, 0x83, 0x5C, 0xC4, 0x97, 0x1A, 0xFC, 0x7F, 0xD5, 0xFF, 0xFB, 0x92, 0x64, + 0x0E, 0x0F, 0xF4, 0x72, 0x35, 0x4C, 0x03, 0xBA, 0xC9, 0xB0, 0x30, 0x85, 0xB9, 0x00, 0x01, 0xA6, + 0x6C, 0x11, 0x60, 0xD3, 0x32, 0x0E, 0xEF, 0x25, 0x00, 0xC6, 0x17, 0x64, 0xC0, 0x10, 0x2C, 0x30, + 0xA2, 0xB9, 0x9D, 0x9E, 0x6F, 0x13, 0x1C, 0x24, 0xC6, 0x26, 0x0C, 0x12, 0x5A, 0x42, 0x26, 0x39, + 0x0F, 0x60, 0x9B, 0x69, 0xAC, 0xD8, 0xCB, 0xCA, 0xAF, 0xDF, 0xF9, 0x3D, 0x85, 0x52, 0x7B, 0xE0, + 0xA5, 0x7E, 0xD9, 0xD3, 0xB8, 0xB4, 0x0E, 0x58, 0xAA, 0x91, 0x72, 0x43, 0xCC, 0xF2, 0x14, 0xBC, + 0x44, 0x83, 0xF7, 0x04, 0x01, 0xA4, 0x6C, 0x02, 0x2B, 0x40, 0x49, 0xBA, 0xA6, 0x7A, 0x0F, 0x72, + 0x72, 0x11, 0x28, 0xF6, 0x89, 0x01, 0x01, 0x43, 0x6F, 0xFC, 0x3A, 0xA3, 0xEE, 0x1B, 0xAE, 0x93, + 0x57, 0x24, 0x92, 0x1F, 0xFF, 0xFC, 0x7B, 0xFF, 0xAB, 0x1A, 0xBD, 0x57, 0x9F, 0x55, 0xF1, 0xA7, + 0xD5, 0x24, 0x2B, 0x37, 0xE6, 0xF3, 0x54, 0x9C, 0xEF, 0xFF, 0x31, 0x8E, 0xC0, 0x57, 0xEE, 0x27, + 0xDC, 0xE7, 0x67, 0x09, 0x26, 0x49, 0x94, 0x62, 0x5A, 0xA4, 0x4A, 0xE9, 0x9E, 0x99, 0x89, 0x79, + 0xFD, 0x42, 0x64, 0x49, 0x8E, 0x31, 0x33, 0xFF, 0xF1, 0xA0, 0x53, 0xCF, 0xFB, 0x93, 0x3E, 0x8E, + 0xB4, 0x89, 0x2F, 0xFF, 0xBB, 0x1B, 0xC4, 0x0D, 0xC3, 0xAF, 0xF6, 0x31, 0x0D, 0xAD, 0x85, 0x82, + 0xF8, 0x7E, 0x75, 0x52, 0x88, 0xC2, 0x60, 0xA5, 0xFC, 0x61, 0x38, 0x1C, 0x61, 0xC1, 0x90, 0x78, + 0x50, 0x6A, 0x63, 0x87, 0x43, 0xCC, 0xA6, 0xCE, 0x06, 0x64, 0xCE, 0x26, 0x66, 0x38, 0x50, 0x04, + 0x61, 0x08, 0xA0, 0x25, 0x93, 0x1D, 0x93, 0x39, 0x92, 0x25, 0x26, 0x23, 0x1A, 0x16, 0xA1, 0x90, + 0x32, 0x09, 0x35, 0xE7, 0x12, 0x52, 0x98, 0x8B, 0x89, 0xC0, 0x94, 0xC6, 0x1B, 0x02, 0x7B, 0x26, + 0xC2, 0x28, 0x30, 0x10, 0xA8, 0x09, 0xC0, 0xE4, 0x93, 0x4D, 0x0F, 0xA3, 0x7B, 0x5C, 0x75, 0xC5, + 0x4A, 0xC9, 0x29, 0x85, 0x4B, 0x8D, 0x05, 0xCB, 0x56, 0xB5, 0x6D, 0x37, 0x25, 0x69, 0xB2, 0x91, + 0xA9, 0x6F, 0x96, 0x99, 0xF2, 0xA5, 0x47, 0x0D, 0xAE, 0xC9, 0xEB, 0x69, 0xD1, 0x14, 0x7C, 0x2F, + 0x7F, 0xFE, 0xEA, 0x7F, 0xE1, 0xBB, 0x93, 0xFA, 0xCB, 0xFF, 0xE0, 0xDA, 0x6F, 0x95, 0xD1, 0xD0, + 0xC1, 0xFC, 0x66, 0x73, 0xBD, 0xFF, 0xDF, 0xE4, 0xA0, 0x2F, 0xC4, 0x92, 0x07, 0xC4, 0x6F, 0x4E, + 0x6C, 0x7B, 0x21, 0x0C, 0x4B, 0xC6, 0xA3, 0x75, 0xD3, 0xB4, 0x43, 0x27, 0xA6, 0x4F, 0xAC, 0xC4, + 0x62, 0xB5, 0xCB, 0xDF, 0xBD, 0xEF, 0xFF, 0x30, 0x41, 0x95, 0xC3, 0x54, 0x54, 0x9F, 0x03, 0xB3, + 0x86, 0x7E, 0x81, 0x2E, 0xF6, 0x15, 0xAD, 0xFF, 0xE5, 0x75, 0xCB, 0xFB, 0xCC, 0xF2, 0x64, 0xEA, + 0x0B, 0x81, 0x06, 0x05, 0x08, 0x66, 0x94, 0xD0, 0x26, 0x0A, 0x07, 0x26, 0x09, 0x33, 0x46, 0x43, + 0x1C, 0xA6, 0x07, 0x89, 0x46, 0x23, 0xBB, 0x00, 0xE2, 0x30, 0x46, 0x02, 0x19, 0x68, 0xFF, 0xFB, + 0x92, 0x64, 0x0F, 0x0F, 0xF4, 0x78, 0x34, 0xCC, 0x83, 0xB9, 0x5B, 0x70, 0x30, 0xE5, 0x99, 0x60, + 0x15, 0x27, 0x78, 0x11, 0xC4, 0xD3, 0x32, 0x0E, 0xEF, 0x25, 0x00, 0xC5, 0x1A, 0x64, 0xC0, 0x30, + 0x20, 0x30, 0x0F, 0x21, 0x89, 0x80, 0xE3, 0x48, 0x40, 0x4C, 0x0D, 0x1F, 0x4F, 0xF7, 0xCA, 0x1B, + 0x10, 0x24, 0x25, 0x2A, 0x87, 0x16, 0xA6, 0x5A, 0xA5, 0x4C, 0x3E, 0x38, 0x96, 0x96, 0x9D, 0x28, + 0x66, 0x24, 0xB0, 0x88, 0xD0, 0x2A, 0x22, 0xED, 0x0A, 0x82, 0x01, 0x10, 0xAC, 0xC8, 0x30, 0x2C, + 0xA9, 0x10, 0xE8, 0x7A, 0x50, 0x03, 0x4E, 0x63, 0x02, 0xC2, 0x30, 0xA3, 0x1D, 0xA5, 0x58, 0xAC, + 0xA4, 0x73, 0xA2, 0x98, 0x56, 0x85, 0x6C, 0x49, 0xF2, 0x23, 0x22, 0xC8, 0xDB, 0x77, 0xD4, 0x56, + 0x79, 0x19, 0x95, 0x8E, 0xB1, 0x08, 0x6E, 0x3B, 0x64, 0x29, 0x8F, 0x9B, 0xAD, 0x23, 0xB6, 0xE4, + 0x0D, 0x2F, 0xCA, 0x58, 0x52, 0x62, 0x5C, 0x4D, 0x23, 0xD3, 0xDF, 0xFD, 0x13, 0xC9, 0x18, 0x94, + 0xA0, 0x04, 0xD7, 0x05, 0x7F, 0xFF, 0xFE, 0xA1, 0x72, 0x01, 0x0B, 0xA0, 0xBB, 0x59, 0x34, 0x91, + 0x34, 0x36, 0x60, 0xE9, 0x17, 0xF1, 0xA5, 0x83, 0x46, 0x2D, 0xE1, 0x72, 0x05, 0x49, 0x7E, 0x5F, + 0x28, 0x37, 0x21, 0x94, 0x1A, 0xD0, 0xFE, 0x50, 0xC7, 0xA1, 0x22, 0x1E, 0xAF, 0xC7, 0xCE, 0x33, + 0xC5, 0x8B, 0x0F, 0x20, 0xBD, 0x00, 0x41, 0x39, 0xB2, 0xCC, 0x81, 0x41, 0x16, 0x61, 0xC9, 0xC0, + 0x74, 0xA8, 0xA6, 0x1C, 0xE4, 0x73, 0x73, 0x67, 0x18, 0x22, 0x62, 0x41, 0x07, 0x06, 0xB2, 0x06, + 0x0F, 0x31, 0x60, 0x60, 0x70, 0x19, 0x85, 0x4F, 0x98, 0xC4, 0x03, 0x58, 0x05, 0x25, 0x32, 0xD5, + 0x12, 0x65, 0x8F, 0x1B, 0xC2, 0xC9, 0xA1, 0xA5, 0x90, 0xF6, 0xAA, 0x8B, 0x48, 0x7A, 0x19, 0x63, + 0x65, 0x0C, 0x54, 0x2C, 0x48, 0x18, 0xF5, 0x9C, 0xBD, 0xD4, 0xF1, 0x61, 0x14, 0x22, 0x6C, 0x02, + 0x33, 0x15, 0x02, 0x8B, 0x26, 0xEC, 0xD4, 0xAC, 0xA1, 0x46, 0x32, 0x7E, 0x18, 0xDF, 0x2D, 0xA0, + 0x30, 0x2B, 0xC4, 0x61, 0x47, 0x96, 0x22, 0x85, 0x93, 0x8E, 0x64, 0x2A, 0x18, 0x42, 0xA8, 0x31, + 0x95, 0x94, 0x06, 0xF5, 0x39, 0x5C, 0xFF, 0xFF, 0xFF, 0xC7, 0x79, 0x7D, 0x8B, 0xFD, 0xEE, 0x3B, + 0xE6, 0x98, 0x6C, 0x17, 0x39, 0x96, 0xA7, 0x70, 0xFF, 0xFD, 0xC9, 0xA6, 0xA2, 0xB3, 0x0C, 0x31, + 0xAF, 0x5F, 0x41, 0xF2, 0x98, 0x58, 0xE8, 0x3A, 0xE9, 0xE4, 0x77, 0x28, 0x2A, 0x20, 0x87, 0xBF, + 0xE5, 0x58, 0xD4, 0x1E, 0x1C, 0x89, 0x86, 0x86, 0xBF, 0xFB, 0x0A, 0xE1, 0xC0, 0x80, 0x1F, 0x17, + 0xDB, 0x5C, 0x54, 0x7E, 0xCB, 0xFC, 0x0A, 0xFF, 0xA0, 0x97, 0xFA, 0x3F, 0x6F, 0xFF, 0x2C, 0xF9, + 0xB7, 0x73, 0x85, 0xEA, 0x2A, 0x81, 0x4C, 0x3C, 0x0A, 0x3B, 0x8C, 0x40, 0xCE, 0xC2, 0x03, 0x21, + 0xCC, 0x4F, 0x6A, 0xE8, 0x32, 0xA8, 0x54, 0xC9, 0x0D, 0x13, 0x29, 0x13, 0xCC, 0x5E, 0x14, 0x32, + 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x74, 0x64, 0x34, 0xCC, 0x83, 0x99, 0x6B, 0xE0, 0x31, 0x06, + 0x99, 0x45, 0x08, 0xE6, 0xC6, 0x92, 0x04, 0xD3, 0x30, 0x0E, 0xEF, 0x26, 0x80, 0xBF, 0x19, 0x66, + 0x54, 0x54, 0x09, 0xF1, 0x92, 0x29, 0x70, 0x10, 0x8E, 0x53, 0xA0, 0x2C, 0x73, 0x31, 0xE1, 0x94, + 0x68, 0x2A, 0x10, 0x3D, 0x57, 0xEC, 0x8A, 0x41, 0x29, 0x6B, 0x9A, 0xAC, 0xD1, 0x1F, 0xB7, 0x6D, + 0x81, 0x3F, 0x8C, 0x4C, 0x1D, 0x12, 0x1B, 0x97, 0x3C, 0x1C, 0x98, 0x74, 0x61, 0x60, 0x5E, 0x54, + 0xD1, 0x2F, 0x62, 0x9E, 0x5E, 0xE3, 0xC2, 0xCB, 0x87, 0x9E, 0x6C, 0x8B, 0x48, 0x9A, 0xC4, 0xEC, + 0x3D, 0xDE, 0x22, 0x41, 0x8F, 0x06, 0xCF, 0x03, 0x25, 0x10, 0xD2, 0x15, 0x52, 0x4E, 0x43, 0x0F, + 0x48, 0xA6, 0x01, 0x83, 0xAE, 0x44, 0x75, 0x86, 0x9D, 0x00, 0xB5, 0x94, 0x75, 0x7F, 0x38, 0x83, + 0xFA, 0xC6, 0x0C, 0x2D, 0xA2, 0x66, 0x64, 0x50, 0x1D, 0x1B, 0x99, 0x86, 0x20, 0x0D, 0x05, 0xD2, + 0x5C, 0x61, 0x46, 0x39, 0xE0, 0x40, 0x00, 0x1C, 0x57, 0xFD, 0x08, 0xC7, 0x7D, 0xC1, 0x08, 0x88, + 0xA8, 0x19, 0x81, 0xD9, 0x4E, 0x80, 0x88, 0x4E, 0x7E, 0x8F, 0x46, 0x5F, 0x72, 0x27, 0x98, 0x25, + 0x96, 0xBE, 0xC8, 0x3C, 0xA4, 0xFF, 0xCE, 0x3B, 0x1B, 0x90, 0x3B, 0xE3, 0xE1, 0x95, 0x3D, 0x3C, + 0x28, 0x4F, 0x19, 0xCB, 0x0A, 0xD7, 0x90, 0x0A, 0x0C, 0x99, 0x89, 0x59, 0x98, 0xFA, 0x12, 0x98, + 0xF8, 0x66, 0x9E, 0xC0, 0xA9, 0x18, 0xA4, 0x15, 0x99, 0x6A, 0xC0, 0x9B, 0x19, 0x58, 0x73, 0x49, + 0xD1, 0xE2, 0x8F, 0x01, 0x98, 0x00, 0x01, 0x9A, 0x04, 0x02, 0x1C, 0x4F, 0x36, 0xC2, 0x27, 0x2C, + 0xD2, 0x12, 0x22, 0xCC, 0x56, 0x52, 0x94, 0xF4, 0x3C, 0x83, 0x16, 0x73, 0x51, 0x71, 0xDE, 0xC6, + 0x18, 0x63, 0x06, 0xCC, 0x16, 0x0D, 0x20, 0xC2, 0xA7, 0x39, 0x2D, 0xAA, 0x46, 0x19, 0xC2, 0xC4, + 0x46, 0x07, 0x53, 0x06, 0xEE, 0x38, 0xBA, 0x34, 0xD0, 0x85, 0x17, 0x7C, 0xCC, 0xCF, 0xD1, 0x60, + 0x42, 0x29, 0xA5, 0x42, 0x40, 0x2E, 0x41, 0xB1, 0x5D, 0x74, 0x69, 0x91, 0xD6, 0xC2, 0x31, 0x32, + 0x4C, 0xC3, 0x25, 0x50, 0xD6, 0x77, 0x97, 0x7B, 0xF2, 0xDE, 0x7F, 0xFE, 0xF3, 0xD5, 0x14, 0xC7, + 0xFF, 0xFF, 0xD0, 0xC5, 0x20, 0x98, 0xD7, 0x61, 0x6E, 0x67, 0x3B, 0xFE, 0xE8, 0x53, 0x35, 0xA5, + 0xF8, 0xF0, 0xBD, 0x2D, 0x7E, 0xFC, 0x00, 0x60, 0x7F, 0xFA, 0x07, 0x14, 0x09, 0xA2, 0x0C, 0xA6, + 0x9F, 0x26, 0x96, 0xD7, 0x14, 0x20, 0x38, 0x51, 0x7E, 0x06, 0xC2, 0x25, 0x4A, 0x58, 0xC2, 0x7F, + 0xFC, 0xE0, 0xD8, 0xB8, 0xEF, 0x47, 0xA9, 0x81, 0x61, 0x10, 0x8B, 0xB7, 0xF9, 0x5F, 0xF2, 0xD4, + 0x8D, 0xE8, 0xC0, 0xD4, 0xBE, 0x15, 0x00, 0xC0, 0x04, 0xB5, 0x30, 0x24, 0x56, 0x32, 0x32, 0x6C, + 0x31, 0x5C, 0x16, 0x00, 0xA1, 0x46, 0xCE, 0x2A, 0x66, 0x08, 0x20, 0x6E, 0x4F, 0xA7, 0x2E, 0x18, + 0x60, 0xE8, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0D, 0x04, 0x6D, 0x34, 0xCD, 0x13, 0xBB, 0xC9, 0x40, + 0x34, 0x46, 0x79, 0x85, 0x1D, 0x22, 0x7C, 0x51, 0x34, 0xD3, 0x32, 0x0E, 0xE9, 0xAD, 0xC0, 0xC8, + 0xA3, 0xE7, 0x5C, 0x11, 0x8A, 0x8A, 0x66, 0x8C, 0xAC, 0x21, 0x00, 0x31, 0x51, 0x54, 0x4F, 0x10, + 0x2E, 0x9A, 0xF8, 0xE8, 0x29, 0x6D, 0x32, 0x02, 0x15, 0x97, 0xB9, 0x7B, 0x76, 0x21, 0xFF, 0x94, + 0xB8, 0x94, 0xD2, 0x88, 0x12, 0x52, 0x4A, 0x64, 0x6D, 0x96, 0x86, 0x1A, 0x0E, 0x07, 0x8F, 0xE2, + 0xA5, 0x02, 0x1D, 0x20, 0xB6, 0xAD, 0x30, 0xCC, 0xB1, 0x2C, 0x1A, 0xA0, 0x81, 0xE7, 0xA5, 0xC8, + 0x07, 0xD8, 0xEB, 0x82, 0x5E, 0x22, 0x15, 0xBB, 0x20, 0x39, 0xFC, 0x7E, 0xA8, 0xF1, 0x92, 0x37, + 0x96, 0x83, 0x9B, 0x9D, 0x6C, 0x63, 0x42, 0x48, 0xE2, 0x19, 0xD6, 0x95, 0x73, 0xFF, 0xEA, 0x5A, + 0xB9, 0x85, 0x37, 0x7F, 0xFF, 0xF7, 0x7A, 0xAC, 0xA6, 0xBC, 0xB6, 0x27, 0x39, 0xFF, 0xA7, 0xDA, + 0x05, 0x86, 0x63, 0xB1, 0x58, 0xEC, 0x52, 0xF8, 0x20, 0x00, 0x02, 0x85, 0xFF, 0xEA, 0x0D, 0x11, + 0x4B, 0xB6, 0x79, 0x4B, 0xF5, 0xD4, 0xC2, 0x4A, 0x7B, 0x38, 0x8A, 0xF5, 0xAA, 0xCE, 0xD9, 0x4B, + 0x9A, 0xFA, 0x17, 0xA4, 0x8A, 0xFF, 0xFF, 0xA7, 0x44, 0xD1, 0xFF, 0x7D, 0x09, 0x33, 0x91, 0x64, + 0x59, 0x7F, 0xF9, 0xBE, 0x1B, 0xAB, 0x1D, 0xFD, 0x86, 0x45, 0x14, 0x06, 0x0E, 0x05, 0x8C, 0x20, + 0x01, 0x8D, 0xAD, 0x2E, 0xCC, 0xBC, 0x0D, 0x4C, 0x5B, 0x16, 0x0F, 0x65, 0x17, 0xC1, 0x46, 0x59, + 0x8E, 0x22, 0x38, 0x19, 0xDE, 0x30, 0x0C, 0x5F, 0x31, 0xE4, 0x10, 0x07, 0x0D, 0x26, 0x0A, 0x01, + 0x22, 0x43, 0x10, 0x24, 0x71, 0x31, 0x7A, 0x04, 0xB5, 0x19, 0x61, 0x89, 0xBC, 0xEF, 0xCA, 0x26, + 0x69, 0xA1, 0xB9, 0xB5, 0x6B, 0x6A, 0x59, 0xC7, 0x2D, 0xC5, 0x84, 0x60, 0x0B, 0x7A, 0xAD, 0x02, + 0x43, 0x95, 0xFC, 0x38, 0xA9, 0x1A, 0x18, 0xA8, 0xA0, 0xE0, 0x09, 0xE8, 0x10, 0x8E, 0x26, 0xDC, + 0xC8, 0x80, 0x59, 0x30, 0x6C, 0x8A, 0x0E, 0x03, 0x87, 0x1F, 0x73, 0x69, 0x8C, 0x54, 0x40, 0x89, + 0xEC, 0xCC, 0x75, 0xCE, 0x71, 0x6C, 0x2F, 0x4A, 0x18, 0xAD, 0x80, 0x60, 0x36, 0xFE, 0x09, 0x54, + 0xA4, 0xB2, 0xFD, 0xFA, 0xEA, 0xF5, 0x54, 0x60, 0xAE, 0x21, 0xCB, 0xBC, 0x6A, 0x22, 0x94, 0x81, + 0xC6, 0x3A, 0x1A, 0x8E, 0x33, 0x68, 0x10, 0x00, 0x04, 0x98, 0x04, 0x1F, 0xF3, 0x08, 0x42, 0xA6, + 0x6A, 0xF6, 0xB0, 0x09, 0xC8, 0x88, 0x58, 0x00, 0x90, 0x44, 0xA1, 0x99, 0x46, 0x81, 0xFF, 0x0E, + 0x9D, 0x0C, 0xE6, 0x2A, 0x95, 0xBF, 0xE9, 0x5E, 0xBD, 0xFC, 0x83, 0xF4, 0xD7, 0x7F, 0xFF, 0xF9, + 0x17, 0xCA, 0xC8, 0x67, 0x7A, 0xFB, 0xC5, 0x3A, 0x68, 0x22, 0x30, 0x41, 0xE5, 0xB9, 0x66, 0x6F, + 0x0B, 0x18, 0x89, 0xFA, 0x6B, 0x8F, 0x20, 0x20, 0x36, 0x6A, 0xC3, 0x99, 0xBB, 0x42, 0x26, 0x19, + 0x11, 0x99, 0x69, 0x8A, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x14, 0x52, 0x34, 0xCC, 0x83, 0x9A, + 0x6B, 0xE0, 0x31, 0xC6, 0x99, 0x70, 0x09, 0x22, 0x7A, 0x12, 0x90, 0xD3, 0x30, 0x0E, 0xE9, 0xEF, + 0x80, 0xBB, 0x90, 0x26, 0xB8, 0x71, 0x95, 0xD0, 0x1C, 0x0A, 0x1D, 0x1D, 0x00, 0x01, 0x86, 0x1E, + 0x3C, 0x9B, 0xA8, 0x68, 0xF4, 0x18, 0x74, 0x2C, 0x60, 0xC0, 0xD3, 0xC5, 0x5D, 0xC6, 0xE7, 0x4F, + 0x6E, 0x2C, 0xD0, 0x7A, 0xC2, 0x24, 0x50, 0xE2, 0x19, 0x89, 0x01, 0x7F, 0xD3, 0x55, 0x23, 0xAA, + 0x25, 0x93, 0x96, 0x8A, 0x61, 0x06, 0x53, 0xD0, 0xC5, 0x0C, 0xA5, 0x5A, 0x28, 0x42, 0xD5, 0x41, + 0x21, 0x49, 0x90, 0x97, 0x54, 0xE6, 0x34, 0x6F, 0x44, 0x69, 0x86, 0x95, 0x4F, 0x8B, 0x08, 0x44, + 0xB8, 0x53, 0xD9, 0x24, 0x93, 0x35, 0x18, 0xE0, 0x88, 0x43, 0x42, 0x8C, 0x8B, 0x02, 0x7F, 0x9D, + 0x59, 0xBD, 0x6F, 0xEA, 0x2E, 0x9F, 0x2A, 0x1F, 0x4F, 0xEC, 0x24, 0xA6, 0xDA, 0xC9, 0xE2, 0xB8, + 0xE4, 0x28, 0x8F, 0x16, 0x0B, 0x62, 0x94, 0x6F, 0xFE, 0x83, 0x3E, 0x44, 0xCD, 0x42, 0x3E, 0xD0, + 0x39, 0x76, 0xA2, 0x40, 0xBA, 0x18, 0x95, 0x5E, 0x0E, 0x11, 0x12, 0x15, 0x2B, 0x1D, 0x8A, 0xB6, + 0x14, 0xAF, 0xFF, 0xF6, 0xE2, 0x70, 0x70, 0x10, 0xEA, 0x61, 0x82, 0xB7, 0xEB, 0xDC, 0x8F, 0x85, + 0xE0, 0x5F, 0x37, 0x9D, 0x94, 0x48, 0xB0, 0x26, 0x04, 0x00, 0x66, 0x0F, 0x88, 0xC6, 0x58, 0xD9, + 0x86, 0x1E, 0x80, 0x46, 0x18, 0x13, 0x87, 0xC8, 0x23, 0x66, 0x2F, 0x03, 0x86, 0x25, 0xAA, 0x42, + 0xCE, 0x5A, 0x72, 0x8C, 0x9C, 0x85, 0xCC, 0x30, 0x5C, 0x0F, 0x2F, 0x98, 0x14, 0x21, 0x33, 0xB0, + 0x11, 0x45, 0x80, 0xA0, 0x82, 0x54, 0x28, 0xDA, 0x32, 0xE4, 0xD5, 0x6C, 0xAE, 0xB4, 0x3D, 0x4C, + 0xB5, 0xEB, 0x2E, 0x7B, 0x0D, 0x18, 0x2A, 0x06, 0x5A, 0xD6, 0x81, 0xC4, 0xC1, 0xA0, 0x5B, 0xAC, + 0x6C, 0x84, 0x08, 0x85, 0x49, 0x73, 0x48, 0x49, 0x05, 0x0B, 0xB2, 0xC8, 0xDF, 0x63, 0x26, 0x00, + 0x9A, 0xAD, 0x11, 0x2A, 0x34, 0x8F, 0x52, 0x10, 0x2B, 0x21, 0x6B, 0x39, 0xA6, 0x84, 0x13, 0x8C, + 0xAE, 0x5F, 0x27, 0xA1, 0x73, 0x2F, 0xC7, 0x29, 0x11, 0xEB, 0x26, 0x9A, 0x9E, 0x64, 0x9B, 0xFF, + 0xE4, 0x77, 0x01, 0x5F, 0x0B, 0x19, 0xBF, 0x87, 0x1C, 0xD2, 0x91, 0xB1, 0x0A, 0x5A, 0xD5, 0x1B, + 0x8D, 0x4B, 0x6B, 0xD0, 0xDC, 0x41, 0x27, 0xA0, 0x16, 0xB8, 0x1E, 0x87, 0x10, 0x00, 0x30, 0x00, + 0x80, 0x00, 0x00, 0x47, 0xF5, 0x7B, 0x7F, 0x1B, 0x04, 0x88, 0x04, 0xB8, 0xE3, 0x76, 0xAD, 0x71, + 0x3B, 0x01, 0xD3, 0x16, 0x39, 0x1C, 0x04, 0x47, 0x8D, 0x0F, 0x18, 0xE0, 0x71, 0x9F, 0xFC, 0x55, + 0x44, 0x60, 0xD9, 0x97, 0xF5, 0x73, 0xE4, 0xDC, 0xB0, 0x8D, 0x12, 0xD5, 0x06, 0x80, 0x06, 0x07, + 0x09, 0xE6, 0x90, 0xA3, 0x26, 0x3C, 0x03, 0x66, 0x16, 0xA4, 0xC7, 0x10, 0xA4, 0xA6, 0x21, 0x83, + 0xC6, 0x03, 0x05, 0xC6, 0x1F, 0x82, 0xFF, 0xFB, 0x92, 0x64, 0x0D, 0x0E, 0x04, 0x59, 0x34, 0xCC, + 0x83, 0xBA, 0x7B, 0x70, 0x34, 0x25, 0x79, 0x88, 0x28, 0xC2, 0x6E, 0x50, 0xD8, 0xC9, 0x34, 0x4E, + 0xED, 0x6D, 0xD0, 0xCB, 0x11, 0x68, 0xF4, 0x34, 0x96, 0x12, 0x85, 0xA4, 0x10, 0x16, 0xE8, 0xB0, + 0x14, 0x09, 0x52, 0x30, 0xC0, 0x40, 0xCC, 0x48, 0xDA, 0xF4, 0x57, 0x20, 0x00, 0xB0, 0x23, 0xC1, + 0x1E, 0x67, 0xA5, 0xE2, 0xCF, 0x50, 0x04, 0xD3, 0xC9, 0xD7, 0xA9, 0x04, 0x0B, 0xC9, 0x3A, 0xD0, + 0x4E, 0x5A, 0x26, 0xEA, 0xBC, 0x9D, 0x13, 0x04, 0x79, 0x04, 0xE6, 0x11, 0x50, 0x9B, 0x78, 0x09, + 0xCC, 0xB7, 0x2A, 0x9B, 0x46, 0x21, 0x4B, 0x46, 0xA4, 0x12, 0x05, 0x9A, 0xB0, 0xD0, 0x7B, 0x0D, + 0x1A, 0x22, 0xE4, 0x97, 0xFF, 0x09, 0xA5, 0x87, 0x96, 0xC9, 0x5A, 0x1C, 0xB5, 0xA3, 0xC3, 0xB5, + 0x70, 0xD7, 0xFF, 0xCB, 0x7C, 0xCD, 0x1E, 0x5C, 0x77, 0x92, 0xBD, 0xDD, 0xFA, 0x6F, 0xE5, 0x81, + 0xB7, 0x7A, 0xED, 0x4F, 0x98, 0x8A, 0x37, 0xAB, 0x0D, 0xCF, 0xDD, 0x18, 0x00, 0x04, 0x00, 0x10, + 0x0D, 0x16, 0x03, 0x85, 0xBF, 0xA8, 0xF7, 0x18, 0x21, 0x2F, 0x67, 0xD7, 0x42, 0xFB, 0x49, 0x64, + 0x34, 0xB0, 0xB3, 0x90, 0xA8, 0x26, 0xC5, 0x6F, 0x62, 0x8C, 0x74, 0xEF, 0xFF, 0xEC, 0x86, 0x3D, + 0x20, 0xDE, 0xE2, 0x10, 0x7D, 0x7F, 0xFF, 0xF9, 0x06, 0x43, 0xB3, 0x1F, 0xAE, 0xF1, 0xA5, 0xC3, + 0x05, 0x1D, 0x19, 0x08, 0x4D, 0x0E, 0x2A, 0xC3, 0x0A, 0xF0, 0x00, 0xEE, 0x73, 0xF9, 0x00, 0x61, + 0xE8, 0x18, 0x61, 0xE2, 0x4C, 0x62, 0x30, 0x18, 0x5E, 0xC0, 0x41, 0x60, 0xAC, 0x48, 0x00, 0x64, + 0x06, 0x02, 0x86, 0xA3, 0xCA, 0x2E, 0xDA, 0x7A, 0x0F, 0x03, 0x45, 0x9A, 0x22, 0xE0, 0x6C, 0x2E, + 0x4E, 0x72, 0xE5, 0x08, 0xA6, 0x51, 0xA9, 0x98, 0x29, 0xAD, 0xA7, 0x39, 0x28, 0x3A, 0x9B, 0xBD, + 0x8B, 0xBE, 0x3E, 0xB4, 0x04, 0x86, 0x5C, 0x03, 0x1C, 0x88, 0x07, 0x29, 0x35, 0xB6, 0x8F, 0x66, + 0x7A, 0xA0, 0xC0, 0x09, 0x92, 0xA4, 0x10, 0x02, 0x17, 0xB4, 0x49, 0xA5, 0x26, 0x49, 0x03, 0x68, + 0xE6, 0x4B, 0xB1, 0x62, 0xD7, 0xD3, 0xC7, 0x68, 0xF1, 0x60, 0xD9, 0x12, 0x86, 0x3F, 0xFC, 0xB3, + 0x75, 0xFE, 0xBD, 0x64, 0x09, 0xE1, 0x91, 0x3E, 0x0F, 0x0D, 0x69, 0x5F, 0x98, 0x1F, 0x24, 0x49, + 0xF0, 0x21, 0xDF, 0xFA, 0x91, 0x93, 0x48, 0x1A, 0xCA, 0x0D, 0x90, 0x04, 0x2B, 0x00, 0xC2, 0x78, + 0xC5, 0x38, 0x97, 0xF9, 0xC7, 0x2E, 0x9A, 0x80, 0x9C, 0x51, 0x8B, 0x69, 0x23, 0x34, 0xE9, 0xAF, + 0x2B, 0xDC, 0x9F, 0x6F, 0xC9, 0x4D, 0x3F, 0xE0, 0x41, 0xF8, 0x83, 0xFA, 0x9F, 0xDD, 0x67, 0xFB, + 0x04, 0x02, 0xC5, 0xDA, 0x5E, 0x4C, 0xA8, 0x30, 0x65, 0x00, 0x03, 0x06, 0x8E, 0x14, 0x0A, 0x1A, + 0xD7, 0xC0, 0x65, 0x42, 0x00, 0xCC, 0xA4, 0xE9, 0xD0, 0x20, 0x32, 0x50, 0xCD, 0x27, 0x63, 0x7E, + 0x01, 0x02, 0xE2, 0xC2, 0x47, 0x38, 0xD0, 0xC8, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x8E, 0x04, 0x87, + 0x34, 0xCC, 0x93, 0x9B, 0x6B, 0x74, 0x33, 0xA3, 0x6A, 0x0A, 0x20, 0x46, 0x6A, 0x90, 0xF0, 0xCD, + 0x36, 0x6E, 0xE9, 0xAB, 0xC0, 0xC8, 0x8D, 0xE8, 0x0C, 0x90, 0x8D, 0xC2, 0x10, 0x24, 0x01, 0x0F, + 0x00, 0x83, 0xF3, 0xB0, 0x18, 0x87, 0x85, 0x41, 0x97, 0x74, 0x86, 0x54, 0xB7, 0x5F, 0x54, 0x84, + 0x80, 0x5F, 0x04, 0xF9, 0x9F, 0x4E, 0x77, 0x75, 0x7F, 0x8F, 0x0D, 0x2F, 0xF2, 0x11, 0x10, 0x70, + 0x3A, 0xD3, 0x44, 0x07, 0xDC, 0x94, 0x10, 0xBA, 0xA8, 0x88, 0x66, 0x70, 0x06, 0x7C, 0x10, 0x21, + 0x03, 0x0C, 0x12, 0x65, 0x0F, 0xE2, 0xC8, 0x46, 0x53, 0x0C, 0x51, 0x72, 0x4B, 0x60, 0x18, 0xCA, + 0xED, 0xBE, 0x82, 0xC0, 0x56, 0x10, 0x6E, 0x72, 0xC5, 0x5C, 0x97, 0x27, 0x60, 0x35, 0x2F, 0xAA, + 0x03, 0xFB, 0x7D, 0x16, 0x41, 0xBD, 0x68, 0x2E, 0x53, 0x8F, 0x61, 0xC8, 0x3C, 0x07, 0x39, 0xF5, + 0x66, 0x47, 0xC6, 0xA1, 0x9C, 0xE2, 0xCF, 0x92, 0xBF, 0xF6, 0xDF, 0x85, 0xBA, 0x13, 0x40, 0x40, + 0xA0, 0x00, 0x12, 0xA0, 0x02, 0x46, 0x47, 0x2E, 0xB0, 0xBD, 0xFD, 0xC2, 0xAE, 0xAC, 0xF2, 0x87, + 0x69, 0x5A, 0x4B, 0x0F, 0x01, 0x06, 0x20, 0x4A, 0xD8, 0xDF, 0x8F, 0x54, 0x24, 0xF3, 0x15, 0x61, + 0xC4, 0x17, 0x02, 0x5E, 0x59, 0xFB, 0xBD, 0x03, 0xC6, 0x27, 0xAD, 0xA2, 0xBF, 0xF8, 0x91, 0xCE, + 0xF9, 0xA0, 0x38, 0x0F, 0x32, 0xAB, 0x98, 0x5A, 0xCF, 0x82, 0x83, 0xD3, 0x0C, 0x84, 0xA3, 0x83, + 0x06, 0x53, 0x11, 0x02, 0x23, 0x04, 0x53, 0xB3, 0x18, 0x01, 0x33, 0x01, 0x00, 0xC3, 0x17, 0x4C, + 0x61, 0x40, 0x08, 0xB1, 0x18, 0x7A, 0x40, 0x80, 0x91, 0x80, 0x1C, 0x18, 0x22, 0x52, 0x44, 0x52, + 0x1C, 0xD3, 0x51, 0x6C, 0x49, 0x1F, 0x14, 0x58, 0x45, 0xC2, 0xD8, 0xD8, 0x7B, 0xD0, 0xEF, 0xA1, + 0xA4, 0x91, 0x9F, 0x17, 0xED, 0x7C, 0x57, 0xC9, 0x78, 0x0F, 0x12, 0x5C, 0xA6, 0x47, 0x88, 0x2B, + 0x0B, 0x7C, 0x64, 0x00, 0x2E, 0x78, 0x06, 0x7E, 0xCA, 0x59, 0x02, 0x40, 0xC0, 0x4B, 0x35, 0xB0, + 0x8C, 0x04, 0x18, 0x22, 0x78, 0x35, 0x8E, 0x72, 0x78, 0xF9, 0x0A, 0x9B, 0x92, 0x26, 0xC6, 0xE1, + 0xC9, 0x19, 0x7D, 0xB9, 0xD6, 0xFA, 0xAB, 0x26, 0x90, 0x08, 0x44, 0xA0, 0xEF, 0x37, 0x7F, 0x5A, + 0x48, 0x1F, 0x30, 0x05, 0xBF, 0xF5, 0x6A, 0x7D, 0x88, 0x00, 0x00, 0x14, 0x02, 0x67, 0x0C, 0xEC, + 0x24, 0xC0, 0x28, 0x18, 0x6F, 0xA6, 0xD6, 0x10, 0x20, 0xCD, 0x5F, 0x12, 0x65, 0xC2, 0xD0, 0x9D, + 0xD4, 0xCC, 0x88, 0x4C, 0x1B, 0x27, 0x74, 0x31, 0x68, 0x1C, 0x38, 0xA1, 0x02, 0x00, 0x68, 0x0B, + 0x30, 0x73, 0x9F, 0xFE, 0xB2, 0x7F, 0x94, 0xFF, 0x0F, 0xE3, 0x0E, 0x2A, 0x00, 0x00, 0x07, 0x01, + 0xC1, 0x1D, 0x1A, 0x1B, 0x31, 0xC4, 0x10, 0x02, 0x30, 0xC8, 0x08, 0xE7, 0xAB, 0x30, 0x60, 0xDC, + 0xDB, 0x7E, 0xF3, 0x92, 0xA0, 0x4C, 0x04, 0x13, 0x34, 0x62, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0F, + 0x04, 0x7A, 0x34, 0x4E, 0x1B, 0x9A, 0x6B, 0x70, 0x2F, 0xA7, 0xEA, 0x6A, 0x18, 0x22, 0x8E, 0x91, + 0xA8, 0xCF, 0x38, 0x0E, 0xE9, 0xAD, 0xC8, 0xBA, 0x8E, 0x67, 0x08, 0x90, 0x99, 0xD2, 0x7C, 0x48, + 0x84, 0x62, 0x24, 0x10, 0x72, 0x84, 0x40, 0x14, 0x35, 0x76, 0xDA, 0xFA, 0x37, 0x82, 0x82, 0xC2, + 0xD7, 0x3B, 0xC8, 0xC6, 0xD2, 0x19, 0xDD, 0x41, 0x13, 0xCA, 0xFE, 0x8C, 0x82, 0x6B, 0x0D, 0x0D, + 0x9A, 0x34, 0x61, 0xD0, 0x4A, 0xD6, 0xD3, 0xE9, 0x64, 0xA1, 0x70, 0x65, 0xE2, 0x47, 0x33, 0x09, + 0x04, 0xB8, 0x2B, 0x88, 0xCF, 0x8F, 0x49, 0xA5, 0x30, 0x9F, 0x9E, 0x00, 0x11, 0x40, 0x9C, 0x00, + 0x61, 0xC3, 0xB0, 0x24, 0x6E, 0x5F, 0x90, 0x40, 0xB2, 0x08, 0xC3, 0x65, 0x4B, 0xBF, 0x5A, 0x1D, + 0xA7, 0x82, 0xBA, 0x15, 0x87, 0x1A, 0xB3, 0x17, 0xDF, 0xFE, 0x74, 0x94, 0x1F, 0xC7, 0x01, 0x3C, + 0x40, 0x50, 0xE8, 0x11, 0x4B, 0xC5, 0x31, 0xE6, 0x42, 0x2E, 0x7F, 0xE7, 0xA8, 0xAF, 0x42, 0x12, + 0x00, 0x11, 0x00, 0x04, 0x56, 0x02, 0xA8, 0x7D, 0x80, 0xB4, 0xF0, 0x21, 0x35, 0xDE, 0x12, 0x28, + 0xBF, 0xE9, 0x9E, 0x48, 0x52, 0xE3, 0x2C, 0xC1, 0x3D, 0xDA, 0x11, 0x88, 0x52, 0x62, 0x34, 0x85, + 0xF7, 0xFA, 0xFF, 0x5F, 0xFF, 0x92, 0xFA, 0xFF, 0xFF, 0xFD, 0x91, 0xB0, 0xC0, 0x8F, 0xD3, 0x64, + 0x10, 0x10, 0x19, 0x9A, 0x0D, 0x18, 0x48, 0x0C, 0x18, 0x3E, 0x44, 0x9A, 0x46, 0x52, 0x18, 0x12, + 0x33, 0x99, 0xC0, 0xFE, 0x9D, 0x32, 0x2F, 0x83, 0x07, 0x93, 0x2A, 0xC4, 0xC3, 0x04, 0x43, 0xF0, + 0xB9, 0x5C, 0x60, 0x60, 0x22, 0x01, 0x07, 0x0C, 0x2F, 0xA5, 0x4A, 0x00, 0x12, 0x18, 0x9D, 0xCE, + 0x4F, 0x57, 0x92, 0x91, 0xD1, 0x82, 0x14, 0x01, 0x26, 0xDE, 0x46, 0xD9, 0x92, 0x38, 0x0E, 0xDA, + 0xCC, 0x53, 0xA6, 0xDA, 0x52, 0xA2, 0xCE, 0x1A, 0x36, 0x87, 0x13, 0x52, 0x91, 0x0C, 0xC0, 0x80, + 0x6F, 0x59, 0x84, 0x24, 0xA2, 0x43, 0x81, 0x0C, 0x59, 0x36, 0x0C, 0x66, 0xEE, 0x04, 0x0C, 0x5A, + 0x04, 0xCD, 0x9A, 0xAA, 0x86, 0xA3, 0x8C, 0x04, 0x81, 0x38, 0x4B, 0x12, 0x50, 0xAE, 0x35, 0xF8, + 0xDC, 0xFB, 0x01, 0x97, 0x04, 0x01, 0x3D, 0xAB, 0x4B, 0xFF, 0xE9, 0x9B, 0x92, 0x41, 0x8C, 0x16, + 0x66, 0x23, 0xCF, 0x9B, 0x18, 0xA8, 0x4E, 0x02, 0xF0, 0x30, 0x87, 0x84, 0x00, 0x01, 0x86, 0xCC, + 0x88, 0xA9, 0x94, 0xC1, 0x14, 0x25, 0xB3, 0x55, 0xC5, 0x85, 0x48, 0x9A, 0x94, 0x4C, 0x11, 0xFE, + 0x19, 0x56, 0x53, 0x31, 0x5B, 0xBE, 0x72, 0xBB, 0xA3, 0xDA, 0xBC, 0xE5, 0x4B, 0x0A, 0x3E, 0x1C, + 0x11, 0x16, 0x6A, 0x3F, 0xD7, 0x27, 0x96, 0xCE, 0xBF, 0xF8, 0x6A, 0x8F, 0x18, 0x06, 0x00, 0x98, + 0xCC, 0x69, 0x98, 0x3E, 0x04, 0x85, 0x03, 0xD3, 0x66, 0x85, 0x03, 0x04, 0x80, 0x53, 0x10, 0x84, + 0x83, 0xBF, 0x45, 0x73, 0x13, 0x88, 0x73, 0x0B, 0x00, 0x50, 0x81, 0x40, 0xFF, 0xFB, 0x90, 0x64, + 0x10, 0x87, 0xF4, 0x56, 0x34, 0x4E, 0x83, 0xB9, 0x53, 0xE0, 0x32, 0xC6, 0x79, 0x30, 0x15, 0xA2, + 0xA6, 0x52, 0x28, 0xD1, 0x38, 0xAE, 0xE9, 0xAD, 0xC0, 0xC4, 0x98, 0xA5, 0x80, 0x24, 0x9E, 0x11, + 0xC0, 0x50, 0xF8, 0xCD, 0xF1, 0xA4, 0xB4, 0xE0, 0xC0, 0xE0, 0xC4, 0x20, 0x11, 0x23, 0x8C, 0x61, + 0x9C, 0x89, 0x96, 0x19, 0x10, 0x60, 0x50, 0x33, 0x53, 0x15, 0x02, 0x99, 0x9F, 0x94, 0x18, 0xDA, + 0xC5, 0x59, 0x33, 0x8B, 0x2F, 0xC9, 0x85, 0x80, 0x94, 0x96, 0x02, 0x25, 0x34, 0x4D, 0x20, 0x38, + 0x6B, 0x67, 0x34, 0x54, 0x80, 0xC2, 0xE7, 0x85, 0x34, 0x44, 0x44, 0x80, 0x30, 0x0D, 0x7D, 0x00, + 0x40, 0xA3, 0x9B, 0x4E, 0x9A, 0x58, 0x34, 0x77, 0x7C, 0x9F, 0x88, 0x3E, 0xBC, 0x56, 0x92, 0xDD, + 0xD9, 0x70, 0xF8, 0x74, 0xDF, 0x42, 0x4F, 0xFC, 0x3D, 0x16, 0x86, 0x01, 0x74, 0x02, 0xC3, 0xF1, + 0x49, 0xFA, 0x82, 0xC9, 0x52, 0x70, 0x6A, 0x0A, 0x48, 0xFC, 0x4D, 0xDA, 0xA4, 0x32, 0x97, 0xD5, + 0x8C, 0xFD, 0x03, 0xC0, 0x63, 0xB2, 0x8B, 0x9D, 0x6C, 0x4F, 0x24, 0x65, 0xD1, 0xCE, 0x58, 0x13, + 0x42, 0xF9, 0x0B, 0xFF, 0xE6, 0x03, 0xCC, 0x6A, 0x1D, 0xA3, 0xF4, 0xCC, 0xBE, 0x6C, 0xC8, 0xA8, + 0xE4, 0xBF, 0xFF, 0xFA, 0xF8, 0x75, 0xD4, 0x04, 0xE5, 0x31, 0x83, 0x38, 0xA8, 0x15, 0x28, 0x84, + 0x04, 0x30, 0x89, 0x04, 0x30, 0xE4, 0x04, 0x30, 0x38, 0x58, 0x30, 0xD5, 0x0D, 0x30, 0x04, 0x2E, + 0x31, 0x9D, 0x49, 0x3F, 0xD4, 0x64, 0x05, 0x28, 0xA6, 0x12, 0x04, 0xC5, 0x9D, 0x30, 0x14, 0x17, + 0x0A, 0x20, 0x81, 0x00, 0x20, 0x30, 0xF1, 0x90, 0x6A, 0x98, 0x25, 0xF6, 0x68, 0x72, 0xE6, 0xBF, + 0x12, 0xA5, 0x5D, 0x50, 0x43, 0x39, 0x43, 0x76, 0x44, 0xB7, 0x94, 0x21, 0xFC, 0x6C, 0x10, 0x2D, + 0x05, 0xE9, 0x70, 0x08, 0x90, 0x2A, 0x42, 0x7A, 0x99, 0xDD, 0x41, 0xD6, 0x1A, 0x68, 0x42, 0xC1, + 0x18, 0x44, 0xF5, 0x33, 0x84, 0x02, 0xC7, 0x83, 0x1F, 0x9C, 0x25, 0x46, 0x14, 0x30, 0x04, 0x61, + 0x58, 0x24, 0x31, 0x76, 0xE5, 0xA5, 0x50, 0x29, 0x74, 0xAD, 0x0C, 0x68, 0x1C, 0x32, 0x27, 0x0C, + 0x3F, 0x99, 0x67, 0x2E, 0x53, 0xFC, 0xE1, 0x9F, 0xFE, 0x21, 0x47, 0x19, 0x24, 0x12, 0x30, 0x9E, + 0x82, 0x5C, 0x98, 0x85, 0x69, 0x91, 0x49, 0x71, 0x9C, 0x70, 0x97, 0xC7, 0x69, 0x70, 0x28, 0xBF, + 0xFF, 0xFE, 0xA4, 0xE9, 0x62, 0x34, 0x57, 0x01, 0x03, 0x91, 0x12, 0x74, 0x63, 0xCA, 0x00, 0x3B, + 0xFF, 0xFD, 0x0A, 0x0B, 0x8F, 0x02, 0xC5, 0xC5, 0x82, 0x71, 0xE2, 0xA0, 0xFC, 0x4E, 0x25, 0x93, + 0xFF, 0xFF, 0xE3, 0x86, 0x04, 0x61, 0x3A, 0xA9, 0x34, 0xCA, 0x8B, 0xC7, 0x8C, 0x86, 0x11, 0xC0, + 0x00, 0x00, 0x20, 0x5D, 0xC3, 0x40, 0x09, 0x89, 0x24, 0x30, 0x71, 0x80, 0x60, 0x28, 0x54, 0x60, + 0x71, 0xF4, 0x60, 0xC0, 0x28, 0x62, 0x01, 0x32, 0x71, 0xF3, 0x80, 0x62, 0x48, 0xFF, 0xFB, 0x92, + 0x64, 0x0F, 0x07, 0xD4, 0x63, 0x34, 0x4F, 0x43, 0xB9, 0x6B, 0x70, 0x2F, 0xA6, 0x29, 0x80, 0x15, + 0x27, 0x84, 0x51, 0xCC, 0xD1, 0x38, 0x0E, 0xE9, 0xAD, 0xD0, 0xBD, 0x9A, 0x65, 0x48, 0x30, 0x28, + 0x68, 0x26, 0x0A, 0x0C, 0x4C, 0x57, 0x03, 0x47, 0x00, 0x33, 0x04, 0xC4, 0x20, 0xC4, 0x10, 0xBD, + 0x61, 0x5F, 0x96, 0xC3, 0xBC, 0xC7, 0xDF, 0xC8, 0x75, 0x7A, 0x42, 0x63, 0xEC, 0x51, 0xBA, 0x34, + 0x95, 0xD4, 0xF8, 0x88, 0x01, 0x72, 0xDB, 0xB6, 0x75, 0xE3, 0x6B, 0x15, 0x27, 0x82, 0xE8, 0x01, + 0xB0, 0x16, 0x40, 0x12, 0x5C, 0xC2, 0xEA, 0x0C, 0x3C, 0x0A, 0x1A, 0x8B, 0x19, 0x45, 0x81, 0x47, + 0x30, 0x1D, 0x3D, 0x8E, 0x40, 0x01, 0x6C, 0x81, 0x48, 0x48, 0xA0, 0x84, 0x3D, 0x18, 0x14, 0xB8, + 0x8F, 0x7B, 0xD4, 0xA1, 0x0D, 0xFB, 0xB3, 0x63, 0x9E, 0xBF, 0xD2, 0x4B, 0xFF, 0x31, 0x0E, 0x60, + 0x92, 0x94, 0x81, 0x78, 0x4A, 0x91, 0x4E, 0xA1, 0x2C, 0x13, 0xC5, 0xB9, 0xD2, 0x39, 0x35, 0x60, + 0x39, 0xBF, 0xFF, 0xF8, 0xD2, 0xCF, 0x2E, 0x2C, 0x16, 0x20, 0x58, 0xFB, 0x27, 0x4F, 0x23, 0x40, + 0xAA, 0xA3, 0x85, 0xFF, 0xFF, 0x70, 0xDA, 0x98, 0x15, 0x18, 0x2A, 0x30, 0x27, 0x60, 0x98, 0xD2, + 0xFF, 0xFF, 0xFC, 0xE1, 0xB9, 0x25, 0x26, 0x3A, 0x24, 0x9B, 0xA8, 0xE8, 0xF9, 0xAC, 0x93, 0x61, + 0xC8, 0xCA, 0x17, 0x32, 0xCC, 0x80, 0x02, 0x41, 0x20, 0x41, 0x93, 0xA0, 0x08, 0xD2, 0xDA, 0x60, + 0x29, 0x00, 0x6C, 0x8F, 0x36, 0x65, 0xA1, 0x10, 0x40, 0x11, 0x98, 0xA8, 0x4B, 0x18, 0x14, 0x07, + 0x11, 0x00, 0x26, 0x0E, 0x0F, 0xE0, 0x6E, 0xE0, 0x43, 0xC9, 0x26, 0xFD, 0x26, 0x12, 0xD4, 0x73, + 0x69, 0x53, 0x02, 0x2A, 0xC6, 0xF1, 0xB6, 0xB3, 0x1F, 0xA7, 0x48, 0x18, 0x02, 0x5F, 0x18, 0x97, + 0xC7, 0x44, 0x81, 0x18, 0x92, 0x26, 0x7C, 0x61, 0xA5, 0xA0, 0x03, 0x28, 0x19, 0x04, 0x08, 0x6C, + 0xC0, 0x08, 0x2E, 0xE9, 0x83, 0x2C, 0x5D, 0x14, 0x36, 0x35, 0xB0, 0x0D, 0x50, 0xC2, 0x60, 0x26, + 0x60, 0x4C, 0x51, 0x0E, 0xEA, 0xB9, 0x8C, 0x26, 0x02, 0x47, 0x90, 0x84, 0x07, 0x02, 0x8D, 0x33, + 0x04, 0xB6, 0x5A, 0xCF, 0x56, 0x3C, 0x7F, 0xFF, 0xFD, 0x42, 0x4C, 0x1D, 0x47, 0xB8, 0x29, 0x84, + 0x30, 0x9A, 0x25, 0x50, 0x54, 0x86, 0x00, 0x97, 0x63, 0x00, 0x8C, 0x30, 0x85, 0xA0, 0x1A, 0x89, + 0x03, 0x3E, 0x31, 0x21, 0x30, 0x96, 0x4E, 0x0D, 0xA9, 0x61, 0xC1, 0x14, 0x3E, 0x16, 0x86, 0x43, + 0xE6, 0xFA, 0x9E, 0x62, 0xA3, 0x75, 0x2A, 0x17, 0xCA, 0x7A, 0xAD, 0xC7, 0x01, 0x41, 0x87, 0x0F, + 0xAD, 0xFF, 0xFF, 0x4B, 0x22, 0x8D, 0xBE, 0x84, 0xD4, 0x63, 0x14, 0x5A, 0x35, 0x80, 0x00, 0x04, + 0x79, 0x58, 0xC8, 0x0A, 0x33, 0x1C, 0x81, 0x31, 0x18, 0x66, 0x61, 0xF9, 0xEA, 0x0E, 0x71, 0x0C, + 0x77, 0x0A, 0x4D, 0xAA, 0x55, 0xCF, 0x00, 0x0D, 0x87, 0x01, 0xA3, 0x10, 0xC9, 0xA3, 0x2C, 0xFF, + 0xFB, 0x92, 0x64, 0x11, 0x05, 0x34, 0x95, 0x34, 0x4E, 0x2B, 0xBA, 0x6B, 0x70, 0x32, 0x26, 0x79, + 0x9D, 0x1C, 0xC5, 0xD0, 0x50, 0xE0, 0xCF, 0x3D, 0x0E, 0xE6, 0x0D, 0xC8, 0xBE, 0x19, 0x67, 0xB8, + 0x80, 0x0B, 0x80, 0x82, 0x01, 0xD0, 0x20, 0xC3, 0x11, 0xE0, 0xD0, 0x92, 0x10, 0x94, 0x33, 0x70, + 0x0B, 0xD6, 0xE1, 0x20, 0x8D, 0x4B, 0x63, 0x68, 0x73, 0x81, 0x5E, 0x0B, 0x5E, 0xC6, 0x92, 0x49, + 0xE4, 0x5D, 0x89, 0xAE, 0xDE, 0xCB, 0x60, 0x01, 0x00, 0x45, 0xDE, 0x45, 0x6C, 0x00, 0x00, 0xD1, + 0xC8, 0x31, 0x46, 0xCA, 0x09, 0xA2, 0x08, 0x63, 0xC5, 0x56, 0x31, 0x61, 0x00, 0x26, 0xD7, 0x79, + 0x0A, 0x33, 0x58, 0x41, 0x42, 0x8C, 0x01, 0xF2, 0x85, 0xED, 0xC1, 0xDB, 0x03, 0x28, 0x64, 0x2C, + 0x45, 0xFD, 0x4E, 0xD4, 0xAA, 0x4E, 0x06, 0x56, 0xAC, 0x32, 0x5C, 0x5F, 0xFF, 0xFF, 0x93, 0x84, + 0xFC, 0x1E, 0xC0, 0x01, 0xE0, 0x90, 0x81, 0x9E, 0x58, 0xEB, 0x31, 0x10, 0x22, 0x12, 0x23, 0xD8, + 0x24, 0x42, 0x74, 0x90, 0x08, 0x06, 0x2A, 0x00, 0x00, 0x31, 0x00, 0x04, 0x61, 0x12, 0xFA, 0x31, + 0x8B, 0xF3, 0x15, 0xAE, 0x45, 0xAA, 0x7C, 0xB9, 0x26, 0x48, 0xC9, 0x7A, 0xAF, 0xF0, 0x81, 0x94, + 0x44, 0x2D, 0xE5, 0x45, 0x87, 0xA6, 0x99, 0xA1, 0x67, 0xD1, 0x33, 0xCF, 0xF6, 0xFF, 0xFF, 0xFF, + 0x2F, 0xF5, 0xC4, 0xC0, 0xE7, 0x9F, 0x00, 0x02, 0xFB, 0x8A, 0x80, 0x26, 0x03, 0x13, 0xA6, 0x2A, + 0x01, 0x84, 0x20, 0x69, 0x86, 0x06, 0xA9, 0x8B, 0x41, 0x41, 0x8A, 0x80, 0x29, 0x88, 0xC5, 0x91, + 0xE8, 0x04, 0xE1, 0x85, 0x80, 0x18, 0xE8, 0x98, 0x6A, 0x40, 0x50, 0x34, 0x06, 0x03, 0x00, 0x21, + 0x26, 0x57, 0xD8, 0x84, 0x31, 0x66, 0xAE, 0xA1, 0xEA, 0xB8, 0x84, 0x39, 0x2F, 0xA4, 0x23, 0xF7, + 0x40, 0xDC, 0xCB, 0x78, 0xD3, 0xE5, 0xB2, 0xD9, 0xC8, 0x7B, 0x4D, 0x64, 0x29, 0x19, 0xF9, 0xA1, + 0x8C, 0x21, 0x82, 0xF0, 0x65, 0x40, 0xA0, 0x05, 0x02, 0x76, 0x9A, 0x52, 0xD1, 0x1A, 0x78, 0x39, + 0xD6, 0x7A, 0x55, 0x05, 0x1B, 0xC0, 0x03, 0x8A, 0x8A, 0xB0, 0x0D, 0x68, 0x2E, 0x58, 0xD0, 0x65, + 0xD6, 0x2A, 0x82, 0x95, 0xF0, 0xF4, 0xB6, 0x92, 0x3B, 0xD7, 0xFF, 0xFF, 0xA1, 0x48, 0x6E, 0x86, + 0x11, 0x11, 0x51, 0xA0, 0x74, 0xBA, 0x95, 0x87, 0x0A, 0x52, 0x1D, 0x32, 0x90, 0x00, 0x0C, 0x16, + 0x00, 0x00, 0x20, 0x60, 0x8B, 0x91, 0x5D, 0x03, 0xE2, 0x6E, 0xD7, 0xF8, 0x47, 0xB4, 0x19, 0xC5, + 0x4F, 0x2F, 0x36, 0x51, 0x97, 0x37, 0xFF, 0xA5, 0x20, 0xC4, 0x40, 0xE6, 0x12, 0x6C, 0x51, 0x4B, + 0x19, 0x64, 0x8D, 0xBA, 0xB5, 0xB8, 0x9B, 0xFF, 0x52, 0x37, 0xD9, 0x22, 0xD5, 0x80, 0x00, 0x03, + 0xC2, 0xCD, 0xCC, 0x38, 0x24, 0x4C, 0xCC, 0x0B, 0x0C, 0x00, 0x09, 0x0C, 0x7E, 0x1A, 0x43, 0x3B, + 0xD3, 0x0A, 0x41, 0x63, 0x36, 0xD0, 0x73, 0x6B, 0xA7, 0x13, 0x14, 0xC4, 0xA3, 0x01, 0x05, 0x83, + 0x43, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x07, 0x34, 0xA1, 0x34, 0xCD, 0xAB, 0xB9, 0x7B, 0x70, 0x2E, + 0x83, 0xFA, 0x0F, 0x2C, 0x43, 0x4E, 0x11, 0x28, 0xD5, 0x38, 0x0E, 0xE6, 0x2D, 0xC0, 0xC7, 0x99, + 0xE6, 0xD0, 0x27, 0x94, 0xC1, 0xDF, 0x33, 0x15, 0x40, 0x31, 0x80, 0xA8, 0x79, 0x8B, 0x46, 0x50, + 0x60, 0x03, 0x5A, 0x9D, 0x50, 0xB0, 0xAB, 0x36, 0xB9, 0x7D, 0x57, 0xEF, 0xBC, 0x7B, 0x60, 0x09, + 0xA4, 0xA9, 0x20, 0x5C, 0x13, 0x1F, 0x53, 0x0C, 0x0D, 0x01, 0x60, 0x54, 0x8C, 0x48, 0x46, 0xAB, + 0x42, 0x90, 0x23, 0xA8, 0x4D, 0x4E, 0x76, 0x1C, 0xA3, 0xC2, 0x24, 0x4D, 0xC4, 0x46, 0xA2, 0x49, + 0xD1, 0x75, 0x4D, 0x31, 0xDC, 0x35, 0x2D, 0x2F, 0x94, 0x0C, 0x0E, 0x14, 0x22, 0x35, 0x9C, 0xCB, + 0x91, 0x1D, 0xF9, 0x65, 0x30, 0xCC, 0xFE, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE8, 0xAF, 0x45, + 0xB9, 0x8B, 0x78, 0x8E, 0x80, 0xC0, 0x24, 0xA1, 0x52, 0x86, 0x53, 0x3B, 0x31, 0xB3, 0x52, 0x7A, + 0x07, 0xD0, 0x9C, 0x17, 0x3B, 0x80, 0x01, 0x82, 0xC8, 0x00, 0x00, 0x00, 0x60, 0x00, 0x14, 0xA2, + 0xF9, 0xAF, 0xC8, 0xAC, 0xF9, 0xA9, 0xD0, 0xE2, 0x9D, 0x4B, 0x52, 0x2F, 0xB2, 0xB6, 0xFF, 0x03, + 0x64, 0x0B, 0x36, 0xA2, 0xEA, 0x39, 0x39, 0x78, 0xC2, 0xD4, 0x28, 0xC1, 0x9B, 0xBF, 0xEA, 0x3E, + 0x13, 0xCF, 0x92, 0x54, 0x02, 0xC1, 0xC0, 0x00, 0x51, 0x9B, 0x00, 0xB9, 0x80, 0x81, 0x30, 0x04, + 0x64, 0x31, 0x20, 0xDF, 0x30, 0x60, 0x15, 0x32, 0x50, 0x4F, 0x3C, 0xB5, 0xE4, 0x31, 0x00, 0x35, + 0x30, 0x9C, 0x32, 0x33, 0xD2, 0x10, 0x14, 0x06, 0x12, 0x00, 0x98, 0x36, 0x2E, 0x9A, 0xE0, 0xC0, + 0x04, 0x93, 0xA6, 0x25, 0x1C, 0x88, 0x28, 0x93, 0x55, 0x5F, 0x99, 0x37, 0x58, 0xDC, 0xF4, 0x6C, + 0xA1, 0x67, 0x1F, 0xD0, 0xC1, 0x38, 0x2D, 0xA4, 0xBB, 0x4D, 0x1D, 0x18, 0xC1, 0xC9, 0x2D, 0xE6, + 0xD1, 0x58, 0x22, 0xB6, 0xEE, 0xC0, 0x92, 0xC1, 0x27, 0x94, 0xB8, 0x00, 0x22, 0x5C, 0x28, 0x12, + 0xEA, 0x94, 0x41, 0x8F, 0xB3, 0x90, 0xD9, 0x9F, 0xD5, 0x0A, 0x58, 0xCB, 0xB5, 0x7A, 0xC5, 0x29, + 0xAD, 0x37, 0xFF, 0xFC, 0x73, 0x48, 0x69, 0x36, 0x1F, 0x29, 0x3C, 0x08, 0x40, 0x1B, 0xE2, 0x97, + 0x1F, 0x63, 0xAC, 0xD4, 0xBF, 0x9C, 0x28, 0x8C, 0x32, 0x2C, 0x38, 0xCB, 0x6C, 0x00, 0x22, 0x02, + 0x00, 0x18, 0xCF, 0x33, 0xDC, 0x76, 0x9E, 0x56, 0xFA, 0x00, 0x60, 0xA5, 0x22, 0x89, 0x19, 0xE8, + 0x7E, 0xAD, 0x16, 0x79, 0x87, 0x4D, 0x43, 0x65, 0x7C, 0x3A, 0x52, 0xB9, 0x67, 0x16, 0x18, 0xE5, + 0x40, 0x6F, 0xFF, 0xFF, 0x51, 0x62, 0xA0, 0xB1, 0xDC, 0xA4, 0x14, 0x97, 0xCC, 0x36, 0x25, 0x00, + 0x80, 0x0B, 0x8A, 0xCA, 0x61, 0x61, 0xB0, 0x63, 0x70, 0x56, 0x60, 0x68, 0x74, 0x34, 0x7B, 0x9A, + 0xD2, 0x3D, 0x18, 0x2E, 0x0F, 0x98, 0xDA, 0x3A, 0x1C, 0xC1, 0x25, 0x98, 0xDE, 0x0D, 0x98, 0x34, + 0x05, 0x19, 0xFE, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x0D, 0xF4, 0x77, 0x34, 0xCE, 0x13, 0xB9, 0x6B, + 0x74, 0x2E, 0xE6, 0x99, 0x55, 0x1C, 0x08, 0xE0, 0x91, 0xAC, 0xD1, 0x38, 0x4E, 0xE6, 0x4D, 0xC8, + 0xC1, 0x1A, 0x65, 0x00, 0x70, 0x27, 0x80, 0x36, 0x1A, 0x14, 0x00, 0x0F, 0x04, 0xE3, 0x2B, 0x81, + 0xCF, 0x53, 0x54, 0x64, 0x26, 0x6E, 0x79, 0x78, 0x81, 0xCC, 0x6F, 0x6A, 0xB0, 0x39, 0xF9, 0x4B, + 0xF7, 0x3F, 0x25, 0x14, 0x3D, 0x03, 0xE5, 0xD0, 0x42, 0x50, 0xE4, 0x9B, 0xAC, 0xF2, 0x52, 0x32, + 0x40, 0x3C, 0x27, 0x2D, 0xA2, 0x90, 0x30, 0xF3, 0x30, 0x24, 0xC2, 0x4C, 0xC7, 0xE9, 0x13, 0x8E, + 0x00, 0x95, 0xC8, 0x58, 0x14, 0xFB, 0x95, 0xCA, 0x18, 0x34, 0x41, 0xA5, 0x08, 0xC8, 0x8A, 0x4A, + 0xD0, 0x4C, 0xA7, 0x19, 0xFA, 0x3F, 0xFF, 0xF1, 0x02, 0x13, 0x32, 0x59, 0xC4, 0xB8, 0x08, 0xF0, + 0x93, 0x04, 0xE8, 0x5C, 0x10, 0x70, 0xB8, 0x12, 0xC8, 0x30, 0xF7, 0x20, 0x0C, 0x30, 0x29, 0xA0, + 0x3C, 0x26, 0x40, 0x00, 0x04, 0x3B, 0x67, 0x9C, 0x3A, 0xED, 0xF8, 0xE1, 0x65, 0x71, 0x72, 0x50, + 0x70, 0xD1, 0x50, 0x6C, 0xF9, 0xFA, 0xA9, 0x79, 0x51, 0x8A, 0xFF, 0xF5, 0x30, 0xC2, 0xA3, 0xE3, + 0xE0, 0xF7, 0x1E, 0x46, 0xFF, 0x24, 0x56, 0xB6, 0xFB, 0x18, 0x0E, 0xF1, 0x57, 0xE3, 0x0A, 0x6B, + 0x38, 0x03, 0x5D, 0x48, 0x05, 0x31, 0x5C, 0x26, 0x33, 0xCC, 0x0B, 0x16, 0x07, 0xCC, 0x8D, 0x00, + 0x4D, 0x66, 0x14, 0x8B, 0x22, 0x61, 0x50, 0x92, 0x67, 0x3F, 0x28, 0x60, 0x58, 0x08, 0x60, 0x40, + 0x6A, 0x61, 0xFC, 0x06, 0x65, 0xF0, 0x26, 0x44, 0x13, 0x0C, 0xEA, 0x81, 0xCC, 0x2A, 0x36, 0x5F, + 0xE9, 0x64, 0xA0, 0xC1, 0x66, 0xFF, 0x5D, 0x0B, 0x56, 0xDD, 0x39, 0x44, 0xA0, 0x90, 0x11, 0x25, + 0xAD, 0xB7, 0x74, 0xE7, 0x94, 0xB8, 0x42, 0xE4, 0x30, 0x47, 0x0C, 0xD0, 0x74, 0x99, 0x37, 0x05, + 0x39, 0x85, 0x93, 0xA6, 0x19, 0x0C, 0x69, 0x4B, 0xA4, 0x20, 0x1B, 0xC6, 0xDF, 0x76, 0x69, 0x5B, + 0xEB, 0x63, 0xA6, 0xA6, 0x7C, 0x30, 0xA1, 0xC3, 0xC0, 0x5F, 0x6B, 0x6A, 0xB2, 0x93, 0x6A, 0xFF, + 0xFF, 0x40, 0xA2, 0x18, 0x48, 0xC8, 0x9B, 0x04, 0x00, 0x05, 0xC8, 0x43, 0x85, 0x74, 0x14, 0x82, + 0x22, 0x45, 0x03, 0xC4, 0x79, 0x84, 0x84, 0xB8, 0x44, 0x80, 0xAA, 0x03, 0x63, 0x8A, 0x99, 0xFF, + 0xFE, 0x72, 0x14, 0x30, 0xB1, 0x1B, 0x83, 0xF3, 0x47, 0x8E, 0x1A, 0x28, 0x5C, 0x0B, 0xB9, 0x10, + 0x07, 0x04, 0x14, 0x03, 0xC5, 0xDF, 0xFD, 0x96, 0x0F, 0xC6, 0xE2, 0x91, 0xB8, 0xDC, 0x97, 0xFF, + 0xFD, 0x91, 0xBE, 0xE7, 0xF8, 0x53, 0x16, 0xDE, 0x09, 0xEE, 0xBB, 0x53, 0x91, 0x43, 0xCA, 0x80, + 0x00, 0x00, 0x03, 0x00, 0x1A, 0xCA, 0xD0, 0x31, 0x08, 0x4D, 0x34, 0xE4, 0x4A, 0x15, 0x13, 0x4C, + 0x3F, 0x08, 0x0D, 0x8F, 0x3C, 0x4C, 0x3B, 0x0F, 0xCC, 0xA7, 0x39, 0x8E, 0x2F, 0xC1, 0xC0, 0x4D, + 0xC0, 0xD0, 0xDE, 0x62, 0x15, 0xFF, 0xFB, 0x92, 0x64, 0x13, 0x05, 0xB4, 0xB2, 0x34, 0xCD, 0xCB, + 0xB9, 0x9B, 0xE0, 0x31, 0xA6, 0x99, 0x78, 0x15, 0x87, 0x92, 0x11, 0xC4, 0xD5, 0x38, 0x0D, 0x77, + 0x25, 0x00, 0xC1, 0x1A, 0xA5, 0xD0, 0x54, 0xA9, 0xD8, 0x72, 0x63, 0x08, 0x12, 0x5E, 0xC0, 0xB8, + 0xDE, 0x60, 0x90, 0x08, 0x8C, 0xF1, 0xD0, 0xCC, 0x1A, 0x8A, 0x2F, 0x1A, 0xC7, 0x3E, 0x72, 0x85, + 0xB5, 0x26, 0xF8, 0xC3, 0x56, 0xEA, 0x8E, 0x89, 0x21, 0x28, 0x19, 0x24, 0x2E, 0xC3, 0x02, 0x56, + 0xC1, 0x2E, 0xD0, 0xB5, 0xCA, 0x10, 0xB0, 0x45, 0x75, 0x94, 0x59, 0x1A, 0xAA, 0x56, 0x9A, 0x22, + 0x46, 0xBA, 0x69, 0x2C, 0x79, 0xA1, 0x2D, 0xB0, 0x93, 0xEC, 0x5E, 0x88, 0xA8, 0x79, 0x37, 0x54, + 0xE4, 0x80, 0x2D, 0x5A, 0xD0, 0x29, 0x10, 0x70, 0x77, 0xAF, 0xFF, 0xFD, 0x22, 0x54, 0x83, 0x0D, + 0xE2, 0x6C, 0x10, 0xD8, 0x04, 0x28, 0x75, 0x09, 0xE8, 0x2C, 0x4C, 0xA4, 0x7C, 0x80, 0x9D, 0x28, + 0x06, 0x23, 0x2B, 0x18, 0x87, 0x10, 0x03, 0x14, 0x1E, 0x00, 0x00, 0xC0, 0x00, 0x03, 0x11, 0xBF, + 0xFE, 0x98, 0xF2, 0x89, 0xF0, 0xED, 0xFB, 0xDD, 0x4E, 0x76, 0x92, 0x46, 0x83, 0x93, 0xD5, 0x05, + 0xA1, 0xDF, 0xF9, 0x41, 0xDC, 0x88, 0x68, 0xA9, 0x10, 0x7D, 0xE7, 0xBF, 0xFF, 0xFF, 0x8D, 0x4B, + 0x9C, 0x98, 0x12, 0x3F, 0x82, 0xD7, 0x8A, 0x9D, 0x46, 0x0A, 0x1E, 0xB9, 0x4B, 0x03, 0x0D, 0xEF, + 0xB3, 0xD4, 0x90, 0xAA, 0x94, 0xCA, 0x2F, 0x33, 0xD1, 0x42, 0x06, 0x92, 0x26, 0x27, 0x85, 0x27, + 0x25, 0x3A, 0x26, 0x61, 0x81, 0xA0, 0x21, 0x94, 0xC6, 0x24, 0xFC, 0xCF, 0x30, 0x84, 0x98, 0x30, + 0x30, 0x2C, 0x67, 0x16, 0x23, 0x53, 0x7D, 0x84, 0x27, 0xBB, 0xC8, 0xC8, 0x8D, 0xD4, 0x57, 0xFD, + 0x21, 0x79, 0xF9, 0x93, 0xF0, 0xAB, 0x2E, 0x17, 0xD0, 0x7B, 0x47, 0xA5, 0x7D, 0x9C, 0xC4, 0xC4, + 0xCA, 0xA2, 0x1C, 0x5C, 0xA8, 0x5B, 0xA0, 0x62, 0x4D, 0x1E, 0x9E, 0x4B, 0xE6, 0xA7, 0x7E, 0x02, + 0x8B, 0xAC, 0x23, 0x94, 0x79, 0x12, 0xFE, 0xDA, 0x53, 0x75, 0x6A, 0x97, 0x0C, 0x0A, 0x24, 0xB6, + 0x2C, 0x29, 0x57, 0x65, 0x1C, 0x2E, 0x2C, 0xFF, 0x2D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xEA, 0xAD, 0x5A, 0x5D, 0x05, 0x88, 0x13, 0x56, 0xC4, 0x0E, 0x25, 0x15, 0xAC, 0x3B, 0xB9, + 0x43, 0x58, 0xB9, 0x1D, 0x15, 0x21, 0x38, 0x24, 0x1C, 0x14, 0x00, 0x70, 0x0C, 0x8D, 0xFF, 0xEC, + 0xDC, 0xAB, 0x6B, 0xEF, 0x48, 0x51, 0x0B, 0x9C, 0x0A, 0x17, 0x0D, 0xF1, 0xA0, 0x48, 0xF3, 0x9B, + 0xEA, 0x7E, 0x79, 0xF7, 0x04, 0xDE, 0xEE, 0xCA, 0xAC, 0x98, 0xB8, 0x58, 0x6F, 0xFF, 0xFE, 0x44, + 0x72, 0x9D, 0x5A, 0x68, 0x77, 0xAB, 0x88, 0x31, 0x6D, 0xAA, 0x87, 0x52, 0x18, 0xC4, 0xE0, 0x94, + 0xCE, 0x60, 0x04, 0xC0, 0x80, 0x0C, 0xC0, 0xA0, 0x08, 0xC3, 0xF4, 0xD4, 0x1C, 0x00, 0x08, 0x80, + 0x03, 0x1B, 0x77, 0x03, 0x0D, 0x80, 0x43, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x87, 0x94, 0x4F, 0x34, + 0xCE, 0x83, 0xBA, 0xA3, 0x70, 0x32, 0x26, 0x99, 0xAC, 0x18, 0x05, 0x18, 0x11, 0x38, 0xD3, 0x3D, + 0x0E, 0xE9, 0xAF, 0x80, 0xB1, 0x9A, 0x66, 0x50, 0x60, 0x14, 0x62, 0x02, 0xC0, 0xA3, 0x1A, 0x10, + 0xE3, 0x29, 0x41, 0xE1, 0xA0, 0x40, 0x1B, 0xAC, 0x4D, 0x43, 0x6E, 0x94, 0xE1, 0x0B, 0xA0, 0x47, + 0x80, 0xCC, 0x1C, 0x91, 0xBC, 0x0A, 0x11, 0x07, 0xD2, 0xB4, 0xF4, 0x59, 0xE8, 0xE0, 0xC2, 0x24, + 0xB1, 0x02, 0xF2, 0x21, 0x1C, 0x45, 0x39, 0xCE, 0xF9, 0xC4, 0xE3, 0x8A, 0x89, 0x2B, 0x6F, 0x68, + 0x56, 0xFA, 0xAE, 0xA5, 0xAC, 0x84, 0x4E, 0x1B, 0x62, 0x09, 0x1F, 0x22, 0x67, 0xCA, 0x0D, 0x3F, + 0x2F, 0x18, 0x1C, 0xDB, 0x65, 0x0C, 0x4B, 0xE7, 0xE0, 0xC7, 0x9A, 0x18, 0x8E, 0x9F, 0xFF, 0xFF, + 0xC4, 0x24, 0x28, 0x8C, 0xD0, 0x10, 0x40, 0x48, 0x91, 0x02, 0x0A, 0x26, 0x46, 0x3C, 0x81, 0x08, + 0x2E, 0x81, 0x0D, 0x02, 0x82, 0xC5, 0xE1, 0x22, 0x00, 0x00, 0x0A, 0x00, 0x00, 0xC0, 0x03, 0x41, + 0x09, 0xF5, 0x6C, 0x6A, 0x15, 0xE8, 0x12, 0x17, 0x95, 0x8C, 0x12, 0x06, 0x17, 0x10, 0x50, 0x27, + 0xF0, 0xE6, 0x16, 0x6A, 0xA6, 0x41, 0xF1, 0x17, 0x45, 0xDC, 0x3A, 0x3A, 0xAF, 0xFF, 0xFF, 0x13, + 0x13, 0x18, 0x44, 0x89, 0xB7, 0xA0, 0xA4, 0x55, 0xCC, 0x1D, 0xC0, 0x08, 0x21, 0x3D, 0xCC, 0x05, + 0x36, 0x0C, 0x1E, 0x0A, 0x44, 0x40, 0x00, 0xA8, 0xA2, 0x66, 0x99, 0x9C, 0x2C, 0x1F, 0x98, 0x92, + 0x09, 0x1A, 0x37, 0x6D, 0x80, 0x88, 0x91, 0xC0, 0x60, 0xC4, 0x34, 0x98, 0x38, 0x18, 0x4C, 0x90, + 0x29, 0x16, 0x2C, 0x52, 0x40, 0xC5, 0x51, 0xA9, 0xF5, 0x15, 0x6E, 0x42, 0x80, 0x6A, 0x5A, 0x54, + 0xD9, 0xC4, 0xC8, 0x43, 0xC3, 0xB4, 0xA4, 0x81, 0x08, 0x84, 0xD8, 0x73, 0x8A, 0x0B, 0x4A, 0xCB, + 0x28, 0x7A, 0x02, 0x45, 0x56, 0x08, 0x22, 0xAB, 0xE4, 0xF8, 0x81, 0x47, 0xC2, 0xE6, 0x90, 0xC1, + 0x75, 0x17, 0xDC, 0x2A, 0x2C, 0x0D, 0xAA, 0x75, 0xFD, 0x22, 0x33, 0x29, 0xC5, 0x14, 0xE7, 0x25, + 0x2C, 0x4A, 0xD4, 0xCA, 0xF8, 0x7C, 0xE2, 0x77, 0x4B, 0x7F, 0xFF, 0xD3, 0x30, 0x12, 0x72, 0x68, + 0xEF, 0x02, 0x0E, 0x12, 0xC1, 0x80, 0x26, 0x82, 0xD8, 0xA8, 0xA7, 0xA2, 0x17, 0xA2, 0x78, 0xC3, + 0x82, 0x94, 0x62, 0x78, 0x30, 0x05, 0x9C, 0x15, 0xEB, 0x91, 0xC9, 0xB9, 0x46, 0x55, 0xA2, 0x61, + 0xF1, 0x85, 0x08, 0x0B, 0xFF, 0x0F, 0xE2, 0x23, 0xBE, 0x30, 0x7C, 0x29, 0xD1, 0xA8, 0x24, 0x45, + 0x10, 0x14, 0xFF, 0xFF, 0xE5, 0x05, 0x71, 0x26, 0x2C, 0x4C, 0xF4, 0x42, 0xA0, 0x71, 0x08, 0x03, + 0x55, 0x5D, 0xC2, 0x00, 0x14, 0xC3, 0x50, 0x74, 0xD1, 0xB0, 0x8C, 0x0C, 0x09, 0x05, 0x01, 0x53, + 0x75, 0x82, 0xD0, 0x10, 0xF2, 0x63, 0xB0, 0x2E, 0x73, 0xC7, 0x40, 0x9F, 0x80, 0x40, 0x54, 0xC9, + 0x54, 0xC4, 0xC3, 0x60, 0x44, 0xC0, 0xB0, 0x1C, 0xC2, 0xFF, 0xFB, 0x92, 0x64, 0x14, 0x0F, 0xD4, + 0xC8, 0x34, 0x4D, 0x83, 0xBB, 0x9B, 0xE0, 0x30, 0x26, 0x89, 0x78, 0x18, 0x0D, 0x1A, 0x11, 0xE8, + 0xD1, 0x38, 0x0E, 0xEA, 0x6F, 0x80, 0xBF, 0x1A, 0x24, 0xC0, 0x60, 0x28, 0x30, 0x15, 0x5C, 0xC0, + 0x10, 0x34, 0x04, 0x08, 0x10, 0x12, 0xA1, 0x3A, 0x05, 0x80, 0x06, 0xA6, 0xA4, 0xF2, 0x92, 0x22, + 0x89, 0x04, 0x40, 0xC2, 0x06, 0xA8, 0x1D, 0x13, 0x11, 0x2D, 0x42, 0x16, 0x7C, 0xF9, 0x09, 0x01, + 0x50, 0x05, 0x99, 0x80, 0x67, 0xAC, 0x40, 0x46, 0x2C, 0x0E, 0x8B, 0x6B, 0x0C, 0xCC, 0xC1, 0x03, + 0x1E, 0xAB, 0x20, 0x21, 0xA6, 0x7A, 0x91, 0x46, 0x2C, 0x28, 0x50, 0x7F, 0x0E, 0x8C, 0x8E, 0x89, + 0x1A, 0x4D, 0x23, 0xB8, 0xF2, 0x14, 0xF4, 0xCA, 0xA0, 0x9C, 0x8E, 0x17, 0xAE, 0x7B, 0xE6, 0x88, + 0x57, 0xFF, 0xFE, 0x4A, 0x8A, 0x99, 0x5C, 0xE8, 0x18, 0x10, 0x04, 0xA4, 0x40, 0x43, 0x5E, 0x0C, + 0xA1, 0x16, 0x15, 0x81, 0xB5, 0x1D, 0x03, 0x9A, 0x53, 0x2E, 0x86, 0xA0, 0x23, 0x76, 0x20, 0x00, + 0x01, 0x00, 0x04, 0x0E, 0xF9, 0xCA, 0x9A, 0x48, 0x12, 0x66, 0x54, 0x70, 0xE8, 0x37, 0xB0, 0x9A, + 0x11, 0xCD, 0xD1, 0xFF, 0xFF, 0x49, 0x2E, 0x70, 0xA5, 0x48, 0xA4, 0x56, 0xE5, 0xF3, 0xDF, 0xFF, + 0xFA, 0xD4, 0x3B, 0x49, 0x15, 0x8C, 0xC7, 0xE3, 0xEA, 0x55, 0x34, 0xE1, 0x89, 0xBB, 0x4A, 0xE0, + 0x43, 0x06, 0x00, 0x43, 0x43, 0xC0, 0x64, 0x57, 0x00, 0x89, 0x86, 0x5F, 0x98, 0x63, 0xC2, 0x69, + 0x93, 0xA1, 0x19, 0xC5, 0x3A, 0x38, 0x28, 0x7A, 0x1A, 0x05, 0x8C, 0xAC, 0x0F, 0x47, 0x8F, 0xB1, + 0x40, 0x2C, 0xC3, 0x83, 0x24, 0xC7, 0xB0, 0x3D, 0x50, 0x92, 0xA5, 0x24, 0x03, 0x1D, 0x15, 0x0E, + 0x19, 0x69, 0xCB, 0xDA, 0x12, 0xF2, 0xA4, 0x31, 0xA1, 0xDE, 0xC7, 0xFC, 0xC8, 0x01, 0x62, 0xEB, + 0xE0, 0x1A, 0x11, 0xA0, 0x52, 0x98, 0x1B, 0x02, 0xFE, 0x59, 0x02, 0xFF, 0x23, 0x1F, 0x55, 0x80, + 0x18, 0x20, 0xAF, 0xDD, 0xF3, 0x0C, 0x1D, 0xD7, 0x47, 0x03, 0x2B, 0x91, 0x11, 0x1E, 0xF0, 0xB0, + 0xC1, 0x61, 0xB9, 0xA6, 0x4A, 0x07, 0x69, 0xE0, 0x62, 0xB4, 0x0F, 0x02, 0xB8, 0x68, 0x1C, 0x74, + 0xC9, 0x7F, 0xFF, 0xF3, 0xA2, 0x80, 0x45, 0x30, 0xB5, 0xB1, 0xA0, 0x35, 0x40, 0xAD, 0x42, 0xE7, + 0x49, 0xA1, 0xD4, 0x44, 0x96, 0x2F, 0x8B, 0xEB, 0x16, 0xA0, 0x58, 0x22, 0xAD, 0x6C, 0x15, 0xC7, + 0xC6, 0xA0, 0x5D, 0x0A, 0x40, 0x45, 0x9A, 0x60, 0x37, 0x05, 0x32, 0x08, 0xA1, 0x14, 0x59, 0xFF, + 0xFF, 0xFE, 0x87, 0xB5, 0x85, 0xC4, 0xE2, 0xA8, 0xF5, 0x1B, 0xFF, 0xF8, 0x0F, 0x8A, 0x4A, 0x0B, + 0x42, 0x58, 0xD8, 0xE2, 0x6D, 0xA7, 0x08, 0xB1, 0x08, 0x23, 0x05, 0x01, 0x3B, 0x2A, 0x88, 0xB8, + 0x06, 0x21, 0x97, 0x66, 0x04, 0x07, 0x04, 0x80, 0x01, 0x80, 0x23, 0x59, 0x94, 0xE6, 0xE0, 0x08, + 0xD3, 0x30, 0x68, 0x6E, 0x37, 0x8A, 0xEC, 0x08, 0x1E, 0xCC, 0x0C, 0xFF, 0xFB, 0x92, 0x64, 0x0E, + 0x85, 0xD4, 0x6E, 0x34, 0x4E, 0x83, 0xBA, 0x9B, 0xE0, 0x30, 0x86, 0x89, 0x27, 0x1C, 0xCD, 0xD0, + 0x11, 0x78, 0xD3, 0x3B, 0x0E, 0xEE, 0x4F, 0x80, 0xB4, 0x9A, 0x25, 0x0C, 0x60, 0x34, 0x30, 0x05, + 0x8C, 0x3B, 0x4C, 0x84, 0x40, 0x71, 0x74, 0xCC, 0x5C, 0x30, 0x86, 0x8E, 0x70, 0x70, 0x10, 0x30, + 0x7D, 0x0E, 0xB1, 0xB2, 0x51, 0x66, 0x48, 0x04, 0xAE, 0x56, 0xB9, 0xA5, 0xF8, 0x98, 0x00, 0x52, + 0x19, 0x40, 0x35, 0x82, 0xE1, 0x6E, 0x8D, 0xFA, 0xB4, 0xC4, 0x42, 0xE7, 0x05, 0xFE, 0x20, 0x3C, + 0x80, 0x78, 0xF1, 0x67, 0xED, 0xF0, 0x1A, 0x4F, 0xAA, 0x60, 0x08, 0x48, 0xC2, 0x4B, 0x98, 0x39, + 0xAE, 0xCC, 0x78, 0x64, 0xB4, 0x6E, 0x3C, 0xB6, 0xD2, 0x0F, 0x6C, 0xFA, 0xCC, 0xC4, 0x5D, 0x21, + 0x5F, 0xFC, 0xDF, 0xC2, 0xB3, 0x7F, 0xFF, 0x44, 0x59, 0x66, 0x02, 0xFC, 0x05, 0x92, 0x39, 0xA4, + 0x68, 0x0E, 0xE8, 0x5C, 0x63, 0x25, 0xA9, 0xC8, 0xE1, 0xEC, 0xF1, 0x1C, 0x0B, 0x18, 0x92, 0x4C, + 0x04, 0x01, 0x00, 0x00, 0x00, 0x41, 0x7F, 0xFF, 0x7C, 0x70, 0x16, 0x04, 0x8D, 0x53, 0x52, 0xFF, + 0x9D, 0xFF, 0xFE, 0x96, 0xE2, 0x00, 0x19, 0x67, 0xEB, 0xA9, 0x3D, 0x16, 0x5E, 0x26, 0xFF, 0xFF, + 0x85, 0x68, 0xB7, 0x59, 0x91, 0xA1, 0xBB, 0xFA, 0x96, 0x38, 0x4B, 0xA1, 0x3B, 0x0D, 0x01, 0x19, + 0xA0, 0x04, 0x2E, 0x0A, 0x0F, 0x18, 0xA8, 0x2B, 0x99, 0xDC, 0x0E, 0x20, 0xD8, 0x34, 0x0C, 0x35, + 0x60, 0x21, 0x32, 0x20, 0x16, 0x30, 0x40, 0x28, 0x36, 0xAE, 0xC9, 0x7F, 0x13, 0xD4, 0xC5, 0xD3, + 0xBC, 0xC2, 0x40, 0x1C, 0x74, 0x06, 0x1C, 0x55, 0x0C, 0x0A, 0x06, 0x82, 0xE0, 0x58, 0xA8, 0xF8, + 0xD0, 0x03, 0xE6, 0xAA, 0x24, 0xCB, 0x90, 0x89, 0x41, 0x30, 0x46, 0x15, 0x81, 0x21, 0xF9, 0x41, + 0x26, 0x02, 0x32, 0xBF, 0x5A, 0x31, 0x60, 0x15, 0xA6, 0xBB, 0x09, 0x92, 0x57, 0x00, 0xF8, 0x05, + 0x40, 0xCC, 0x70, 0x1A, 0xCF, 0x0B, 0x99, 0x37, 0x29, 0x2E, 0xEC, 0xCC, 0x3A, 0x02, 0x44, 0x22, + 0x0A, 0x79, 0x07, 0x40, 0x9B, 0xFC, 0xD9, 0xDA, 0x6C, 0xED, 0xE0, 0x97, 0xE7, 0x2C, 0x1E, 0x06, + 0x90, 0xDF, 0x7B, 0x92, 0xFF, 0xFF, 0x40, 0x59, 0x0B, 0x2C, 0x80, 0x86, 0x2C, 0x17, 0x84, 0x78, + 0x0C, 0x92, 0x76, 0xCA, 0x92, 0x48, 0x0E, 0x91, 0x2C, 0x20, 0xE5, 0x77, 0xAD, 0x80, 0x01, 0xD8, + 0xD4, 0x4B, 0x8D, 0x2D, 0x58, 0xC6, 0x6F, 0x41, 0x6E, 0xA6, 0xFE, 0xB7, 0xFD, 0x3E, 0xA0, 0x74, + 0x08, 0x9C, 0xB9, 0x1C, 0x64, 0x89, 0x25, 0x28, 0x99, 0x98, 0x7F, 0xFF, 0x99, 0x14, 0xA2, 0x38, + 0x7B, 0xFF, 0x44, 0x7B, 0x38, 0xE1, 0x13, 0x92, 0x9B, 0x55, 0x08, 0x2C, 0x3A, 0x26, 0x3F, 0x44, + 0x1C, 0xB8, 0x4E, 0x60, 0x60, 0xE9, 0x80, 0x4C, 0xC7, 0x13, 0x68, 0x98, 0xAC, 0xD8, 0x4C, 0x5A, + 0x9C, 0x29, 0x9B, 0x04, 0x48, 0x19, 0x38, 0xF1, 0xF1, 0x20, 0x93, 0x47, 0x97, 0xFF, 0xFB, 0x92, + 0x64, 0x11, 0x87, 0x14, 0x99, 0x34, 0x4E, 0x0B, 0x9D, 0xD9, 0x84, 0x32, 0x06, 0x59, 0x51, 0x1D, + 0x85, 0xD0, 0x51, 0xA8, 0xD1, 0x3D, 0x0D, 0x77, 0x64, 0x40, 0xC5, 0x9A, 0x26, 0xE0, 0xC0, 0x1C, + 0x9A, 0xC0, 0xD9, 0x7C, 0x8F, 0x60, 0x09, 0xA6, 0x16, 0x13, 0xCC, 0x10, 0x19, 0xB1, 0x08, 0x86, + 0x00, 0x45, 0xAF, 0xCB, 0x08, 0x4D, 0x3A, 0x6A, 0x85, 0xB0, 0x93, 0xCD, 0x0D, 0x22, 0xA6, 0x7B, + 0xC0, 0x54, 0x1B, 0x77, 0xA6, 0xCC, 0x14, 0xA4, 0x0E, 0x3B, 0x75, 0x39, 0x83, 0x16, 0x5C, 0xC6, + 0x30, 0x0E, 0x01, 0x82, 0xE4, 0x45, 0xAA, 0x86, 0x20, 0x03, 0x2B, 0x48, 0x73, 0x6D, 0x01, 0x41, + 0xD5, 0xF4, 0xA5, 0x74, 0xA7, 0x16, 0x0D, 0x81, 0xEF, 0xCD, 0xEA, 0x1A, 0x00, 0xC2, 0xE3, 0x66, + 0xBD, 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x20, 0xBE, 0x3E, 0x21, 0xC1, 0xD0, + 0xA5, 0xF0, 0x30, 0x55, 0x12, 0xB1, 0x29, 0xDF, 0x28, 0x67, 0xA9, 0x9B, 0xB1, 0x10, 0x2B, 0x30, + 0x94, 0x20, 0x11, 0xF2, 0x63, 0x86, 0xBF, 0xFF, 0xCF, 0x52, 0x6D, 0x70, 0x22, 0xDD, 0x41, 0xFB, + 0x98, 0x63, 0x1E, 0xFE, 0x50, 0x24, 0x73, 0xE8, 0x43, 0x4B, 0x9F, 0x71, 0xD8, 0xA1, 0x67, 0x1B, + 0xC0, 0x2A, 0xCA, 0xDC, 0xC4, 0x76, 0xFF, 0xFF, 0x40, 0x10, 0xA1, 0xE8, 0x83, 0x71, 0x30, 0x3A, + 0xB8, 0xD2, 0xAA, 0xC0, 0x03, 0x02, 0x15, 0x02, 0x6B, 0x2A, 0x1B, 0xE5, 0xA0, 0x40, 0xC7, 0x40, + 0xC9, 0x90, 0xE4, 0x71, 0x83, 0xA0, 0x01, 0x94, 0x62, 0x79, 0xA1, 0x74, 0x28, 0x38, 0xB0, 0xC2, + 0x86, 0x0E, 0x17, 0x90, 0x0C, 0x58, 0x22, 0x23, 0x32, 0xDF, 0x53, 0x52, 0x0D, 0x5C, 0x62, 0x32, + 0xB4, 0x82, 0x69, 0x42, 0x84, 0x8D, 0xC6, 0x93, 0xA5, 0x01, 0x52, 0x78, 0x29, 0x3D, 0xE2, 0xD4, + 0x86, 0x16, 0x18, 0xF7, 0x3E, 0xC5, 0x61, 0x4D, 0x75, 0x43, 0x4C, 0x76, 0x1C, 0x59, 0xC5, 0xCB, + 0x43, 0x80, 0xF1, 0x04, 0xA5, 0xBB, 0x13, 0x07, 0xE3, 0x3E, 0xDE, 0x36, 0x2A, 0xE6, 0x1C, 0x5F, + 0x45, 0x98, 0x80, 0x2D, 0xD5, 0xAE, 0x81, 0x4D, 0xF7, 0xD3, 0xC1, 0xFB, 0x86, 0xDE, 0x48, 0x7A, + 0x62, 0x9F, 0x2F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0xD6, 0xAF, 0xC4, 0x4B, 0xB9, + 0x6B, 0x13, 0x07, 0x05, 0x96, 0xE0, 0xEF, 0x76, 0xE3, 0x89, 0x96, 0xDE, 0x25, 0x10, 0x78, 0x22, + 0xA8, 0x00, 0x60, 0x01, 0x0C, 0x13, 0xF8, 0x0D, 0x26, 0xCF, 0x63, 0x1F, 0x1C, 0xBF, 0x51, 0xE8, + 0xF9, 0xE0, 0xEC, 0x63, 0xCC, 0x80, 0xB1, 0xF2, 0xA5, 0xD0, 0x73, 0xA9, 0xE5, 0xD4, 0x38, 0xB1, + 0x51, 0x1C, 0x79, 0xD1, 0x31, 0xBB, 0xFF, 0xFF, 0xF3, 0xCB, 0xB1, 0x51, 0xBF, 0xA9, 0x99, 0x51, + 0x7C, 0x7D, 0x80, 0x00, 0x18, 0x00, 0xDB, 0xA4, 0x01, 0x86, 0x25, 0x71, 0x9B, 0xE0, 0x48, 0x14, + 0x24, 0x30, 0xF0, 0x5B, 0x16, 0xB8, 0x0C, 0x08, 0x06, 0xCC, 0x9A, 0x0C, 0x0C, 0x4E, 0xB1, 0xFF, + 0xFB, 0x92, 0x64, 0x0E, 0x8D, 0x94, 0x67, 0x34, 0xCE, 0xB3, 0xBB, 0x9B, 0x70, 0x30, 0xA5, 0xD9, + 0xF4, 0x28, 0x45, 0xA6, 0x51, 0x38, 0xD1, 0x3A, 0x0E, 0xE9, 0xEF, 0x48, 0xAA, 0x17, 0x66, 0xE0, + 0x64, 0x15, 0x58, 0x84, 0x83, 0xF6, 0xBA, 0x60, 0x7A, 0x9E, 0x9E, 0xE3, 0xA0, 0xC9, 0xCA, 0x6A, + 0x9A, 0x28, 0x2A, 0x91, 0x0A, 0x0C, 0x83, 0x93, 0xDF, 0x11, 0x08, 0xD2, 0x6B, 0xD3, 0x2B, 0x3B, + 0xA9, 0x5F, 0x12, 0xE5, 0x67, 0xD3, 0x10, 0x05, 0x7B, 0xAF, 0xA9, 0xB5, 0x44, 0xF7, 0x31, 0x48, + 0x71, 0x22, 0xF2, 0xCE, 0x24, 0xB1, 0x11, 0x4D, 0x58, 0xF8, 0xD0, 0xF5, 0x89, 0x63, 0x63, 0x7A, + 0xD5, 0x94, 0xCB, 0x46, 0x20, 0x67, 0xF0, 0x50, 0x42, 0x04, 0x8E, 0xB0, 0x6A, 0xBA, 0x6B, 0x10, + 0xAA, 0x49, 0x96, 0xA2, 0xFA, 0xD0, 0x33, 0x64, 0x13, 0xFF, 0xFF, 0xAC, 0x5E, 0x06, 0x25, 0x27, + 0x47, 0x40, 0x1F, 0x0C, 0x1B, 0x19, 0x0C, 0x16, 0x15, 0x44, 0x0E, 0xB5, 0x0C, 0xB8, 0x69, 0x22, + 0x28, 0x32, 0x0C, 0x00, 0x00, 0x0C, 0x67, 0x2A, 0xA4, 0x88, 0xFF, 0xFC, 0xCC, 0xF1, 0x51, 0xF1, + 0x70, 0x23, 0x0F, 0xD5, 0xE2, 0xF2, 0xC1, 0x90, 0xE7, 0xE1, 0x80, 0x18, 0x04, 0x75, 0x2B, 0x8A, + 0x6D, 0x5C, 0xD1, 0x2E, 0xCA, 0xD0, 0xC3, 0x66, 0x7F, 0xFF, 0xFE, 0x47, 0x60, 0xB0, 0x01, 0xBF, + 0xA6, 0xE8, 0xA0, 0xB8, 0x82, 0x04, 0x8C, 0x23, 0x1B, 0xC4, 0xA3, 0x30, 0x80, 0x3C, 0xC4, 0x92, + 0x10, 0xC3, 0x92, 0xE4, 0xC0, 0xC0, 0x90, 0xC3, 0x92, 0x4C, 0xD9, 0x4A, 0x3D, 0x15, 0x87, 0x81, + 0x33, 0x20, 0x10, 0x46, 0xA6, 0x42, 0x0B, 0x18, 0xC4, 0x74, 0x07, 0x0A, 0xCF, 0xE2, 0x34, 0x0F, + 0x2F, 0x6B, 0xA3, 0x87, 0x84, 0x8D, 0xD3, 0x2C, 0x95, 0x79, 0x76, 0x48, 0x3C, 0x82, 0x5B, 0x2B, + 0x08, 0x3C, 0xF3, 0x66, 0x14, 0x03, 0x1C, 0x66, 0x46, 0xA3, 0x50, 0x38, 0xF3, 0x39, 0x43, 0x62, + 0x25, 0x32, 0xE7, 0xAE, 0x29, 0x1D, 0xE5, 0xB7, 0xAD, 0x55, 0x48, 0xA4, 0x2D, 0x58, 0x90, 0x84, + 0x4D, 0x9D, 0x80, 0xAB, 0x66, 0xB1, 0xA1, 0x1D, 0x74, 0xDC, 0x81, 0x3F, 0x99, 0x95, 0x7A, 0xFF, + 0xFF, 0xE9, 0xAF, 0xFE, 0x29, 0xFF, 0xFF, 0x98, 0x03, 0xCD, 0x54, 0x0E, 0xE1, 0xBA, 0x19, 0x47, + 0x71, 0x5F, 0x65, 0x60, 0x64, 0x69, 0x70, 0x2B, 0xA8, 0x4A, 0x98, 0x24, 0x62, 0x0C, 0xC0, 0xB9, + 0xA1, 0x31, 0x1F, 0xDE, 0xE9, 0x05, 0x3F, 0xF3, 0xE4, 0x8A, 0xC4, 0xB9, 0xC0, 0x3B, 0xDB, 0xE6, + 0xE0, 0x28, 0xA9, 0x4E, 0x67, 0x21, 0xCA, 0xB4, 0x0B, 0x12, 0xB0, 0x90, 0xB0, 0xB7, 0xFB, 0xFF, + 0xFF, 0xF4, 0x34, 0xA3, 0x5B, 0x91, 0x3E, 0x6D, 0x6B, 0x82, 0xA0, 0x04, 0x04, 0x10, 0xF3, 0x11, + 0x30, 0x60, 0x21, 0x05, 0x30, 0x70, 0x65, 0x19, 0x36, 0x84, 0x01, 0x82, 0xF8, 0x2F, 0x98, 0x1A, + 0x02, 0xA9, 0xA4, 0x79, 0x18, 0x19, 0xAC, 0x0E, 0x62, 0x02, 0xA9, 0xE9, 0xEE, 0xE4, 0x21, 0xB0, + 0xA8, 0xFF, 0xFB, 0x92, 0x64, 0x14, 0x8F, 0x14, 0xEB, 0x34, 0xCD, 0x03, 0xDC, 0xD2, 0x20, 0x30, + 0xE3, 0x59, 0xEC, 0x09, 0x82, 0x32, 0x11, 0x2C, 0xD5, 0x3A, 0x0E, 0xE9, 0xEF, 0x80, 0xCC, 0x97, + 0xE8, 0x74, 0xC1, 0x89, 0x79, 0x90, 0xD8, 0xE5, 0xC0, 0xC2, 0xC2, 0x03, 0x88, 0x62, 0x01, 0x91, + 0x28, 0xD0, 0xCC, 0x25, 0x82, 0x95, 0x31, 0x92, 0x23, 0x12, 0x21, 0x41, 0x00, 0xA0, 0x35, 0xDC, + 0x31, 0x6B, 0xB1, 0x98, 0x00, 0x04, 0x5A, 0x85, 0xC8, 0x3E, 0x30, 0x87, 0x98, 0x36, 0xE2, 0x88, + 0xD1, 0xBE, 0x81, 0xA6, 0x0D, 0x0F, 0x8F, 0x36, 0x15, 0x5E, 0xE0, 0x0E, 0x0A, 0x33, 0xC4, 0xE1, + 0xA5, 0xB6, 0x62, 0x49, 0x40, 0x8C, 0x2C, 0x39, 0x55, 0xFA, 0x43, 0x00, 0x17, 0x91, 0xC5, 0xED, + 0x22, 0x98, 0x58, 0x06, 0xA5, 0xFF, 0xFF, 0xFF, 0xAA, 0x97, 0xBE, 0xA5, 0x8D, 0x6F, 0xFF, 0xFF, + 0xEE, 0x28, 0xD3, 0x85, 0x16, 0x25, 0x14, 0xC1, 0x9F, 0xA7, 0x0D, 0x51, 0x4A, 0xD9, 0x50, 0x90, + 0xB8, 0x62, 0x44, 0x4C, 0x2E, 0x06, 0x7F, 0x11, 0xD3, 0x84, 0x00, 0x00, 0xA0, 0x00, 0x0C, 0x00, + 0x94, 0x58, 0x70, 0xF8, 0x72, 0xC1, 0x7C, 0x5E, 0x57, 0x1F, 0x3A, 0x69, 0x41, 0x13, 0xD4, 0xA2, + 0xE0, 0x67, 0x3D, 0x09, 0xE1, 0x80, 0x40, 0x16, 0xCB, 0x42, 0x12, 0x0E, 0xC5, 0xBC, 0xF9, 0x47, + 0x75, 0x7E, 0x7C, 0x44, 0x11, 0x0C, 0x13, 0x68, 0x8D, 0x04, 0xE1, 0xD4, 0x18, 0x30, 0x38, 0xAD, + 0x31, 0xF8, 0x2A, 0x53, 0x53, 0x22, 0x0B, 0xD3, 0x1D, 0x87, 0x80, 0x20, 0x1E, 0x62, 0x59, 0x2C, + 0x75, 0x60, 0xC8, 0x61, 0xD0, 0x42, 0x21, 0x13, 0x8D, 0x8A, 0x2D, 0x07, 0x85, 0xA4, 0x17, 0x30, + 0xD0, 0x93, 0x7B, 0x1C, 0xE0, 0x49, 0x66, 0x08, 0xFF, 0x8E, 0xA0, 0x53, 0x6E, 0x34, 0x82, 0xB0, + 0x17, 0xDB, 0x3A, 0x17, 0x4C, 0xA6, 0x42, 0x9B, 0xC2, 0xE3, 0x41, 0xC4, 0x1C, 0xD6, 0xCA, 0x64, + 0x2F, 0xAE, 0xF7, 0x89, 0x47, 0xD6, 0x9D, 0x3A, 0x64, 0x4F, 0xE6, 0xDC, 0x60, 0xF8, 0xF0, 0xA8, + 0x64, 0xA2, 0x7B, 0xD9, 0x8A, 0x7C, 0xE6, 0xF6, 0x91, 0x04, 0xA5, 0xB4, 0xEB, 0x53, 0x4C, 0x52, + 0xC3, 0x76, 0x27, 0xA4, 0x5F, 0xFF, 0xEF, 0x95, 0x7E, 0xBD, 0xBE, 0x23, 0xFC, 0x53, 0xDF, 0x92, + 0x3C, 0xF4, 0x2C, 0xC6, 0x63, 0x36, 0x4F, 0xBE, 0x3E, 0x06, 0xB3, 0x40, 0xD1, 0x21, 0xCC, 0xE6, + 0x70, 0x99, 0xC5, 0xDE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x46, 0x4D, 0xC4, 0xB0, 0x4C, 0xEA, + 0x94, 0xA4, 0xEC, 0x3F, 0x08, 0x5B, 0xCA, 0x86, 0x82, 0xBC, 0x28, 0x83, 0x0A, 0x8D, 0x4D, 0x7F, + 0xE9, 0x2F, 0x1D, 0x38, 0xC3, 0x89, 0x87, 0xA3, 0x3E, 0xD3, 0x2D, 0x7F, 0xD5, 0xBA, 0x7F, 0x35, + 0x10, 0xC8, 0x29, 0xAA, 0x7C, 0xBC, 0x55, 0x6E, 0x20, 0xD0, 0x10, 0xC1, 0x41, 0xFC, 0xDC, 0x21, + 0x20, 0x28, 0x08, 0x18, 0xD8, 0x14, 0x1C, 0x60, 0x16, 0x18, 0x0C, 0x0E, 0x99, 0x62, 0x8F, 0x98, + 0x76, 0x9B, 0x98, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x94, 0x7B, 0x34, 0x4E, 0x03, 0xBA, 0x7B, + 0x60, 0x32, 0xC6, 0x59, 0xA2, 0x2C, 0xC2, 0x76, 0x50, 0xD4, 0xD1, 0x3C, 0x0E, 0xE1, 0xEE, 0xC0, + 0xB8, 0x19, 0x65, 0x18, 0x27, 0xA9, 0x9B, 0x4E, 0x03, 0x18, 0x60, 0x89, 0x19, 0x7E, 0x66, 0x95, + 0x01, 0xC5, 0xA4, 0x62, 0x2D, 0x0F, 0x1B, 0x4B, 0x83, 0x1A, 0x14, 0x58, 0x0C, 0x32, 0x82, 0x25, + 0x96, 0xCD, 0xC2, 0xE1, 0x47, 0x84, 0x64, 0xF6, 0xAF, 0x68, 0xF0, 0x00, 0x02, 0x11, 0xB9, 0x68, + 0x20, 0x59, 0x76, 0x59, 0x38, 0x25, 0x52, 0x23, 0xC4, 0x90, 0x8D, 0xAD, 0x43, 0x6A, 0x06, 0xA4, + 0x57, 0x21, 0x7E, 0x1C, 0x24, 0x87, 0x59, 0xF1, 0xD7, 0x51, 0x6D, 0xB1, 0x46, 0x98, 0x79, 0x04, + 0x4C, 0x4B, 0x97, 0x99, 0x1B, 0xA6, 0x42, 0x31, 0xE6, 0xDF, 0xFF, 0xBC, 0xCD, 0x22, 0x67, 0xCF, + 0x24, 0x6C, 0xB3, 0xE1, 0xF2, 0x10, 0x9F, 0x39, 0x32, 0xE9, 0x00, 0x28, 0x4D, 0x71, 0xC0, 0x96, + 0xE4, 0x18, 0xF0, 0x54, 0x92, 0x95, 0x88, 0x64, 0x09, 0x6D, 0x00, 0x18, 0x01, 0x48, 0x88, 0x14, + 0x4D, 0x6B, 0x44, 0xEE, 0x6A, 0xB7, 0xC0, 0x64, 0x59, 0x00, 0xD4, 0x0C, 0x2A, 0xFE, 0x77, 0x4D, + 0xC5, 0x07, 0x9E, 0x70, 0xBC, 0xFC, 0xB3, 0x23, 0x89, 0x0B, 0x45, 0x5F, 0x0C, 0x18, 0x93, 0x8C, + 0x6F, 0x2F, 0xF6, 0x5F, 0xFD, 0x56, 0x6B, 0x3C, 0xB6, 0x83, 0x0E, 0x56, 0x86, 0xE6, 0x92, 0xC6, + 0x0D, 0x18, 0xC6, 0xF3, 0x04, 0x08, 0xD2, 0x60, 0xE9, 0xE8, 0x66, 0x71, 0x0E, 0x60, 0x90, 0x52, + 0x61, 0xC0, 0x6C, 0x72, 0x18, 0x28, 0x60, 0xF8, 0x04, 0x61, 0x19, 0x44, 0x6E, 0x68, 0xDC, 0x8F, + 0xEC, 0x20, 0x02, 0x16, 0x21, 0x03, 0xBE, 0x56, 0x27, 0x37, 0x24, 0xC9, 0x45, 0x07, 0x58, 0x10, + 0x11, 0xA0, 0xD8, 0x50, 0xE9, 0x53, 0x33, 0x2E, 0x92, 0x39, 0xB9, 0x25, 0x9A, 0x06, 0x81, 0xC7, + 0x08, 0xA0, 0x38, 0xD8, 0x61, 0x9B, 0xE3, 0x0C, 0xDC, 0x3D, 0xCC, 0x20, 0x33, 0xB2, 0xB0, 0x9D, + 0x6C, 0xE6, 0x09, 0x09, 0x53, 0x2E, 0x4C, 0x22, 0x43, 0x00, 0xE4, 0x92, 0x12, 0xA4, 0xE0, 0x7E, + 0xA3, 0xDF, 0xFF, 0xFF, 0xDB, 0xD8, 0x2C, 0xE1, 0xE8, 0xE7, 0xBF, 0x2A, 0xAE, 0x3E, 0xD4, 0x6A, + 0x33, 0x51, 0x4C, 0xAF, 0x25, 0xE8, 0xC4, 0xC1, 0xBF, 0x12, 0xAB, 0xE8, 0x03, 0xA8, 0xA0, 0x6D, + 0x2F, 0x03, 0xD4, 0xFA, 0x00, 0x14, 0x2A, 0x7F, 0xF6, 0x26, 0x26, 0x2B, 0xE8, 0x3A, 0x61, 0x8B, + 0x5A, 0xCA, 0xA3, 0xAF, 0x5C, 0x3B, 0xAD, 0x48, 0x50, 0xDF, 0xE8, 0x3E, 0x5F, 0x56, 0xD5, 0x86, + 0x40, 0xD6, 0x7E, 0x67, 0xFF, 0xB2, 0x3F, 0xFD, 0x3C, 0xC0, 0x2E, 0x38, 0xE9, 0xCA, 0x3D, 0x26, + 0xC5, 0x95, 0x75, 0x44, 0x80, 0xE3, 0x0B, 0xA3, 0xC3, 0xD3, 0x01, 0x70, 0xE0, 0xA4, 0xCE, 0x78, + 0x98, 0x78, 0x9A, 0x31, 0x14, 0x5C, 0x31, 0x05, 0x80, 0x34, 0x2C, 0x26, 0x4F, 0x03, 0x26, 0xAD, + 0x33, 0x5C, 0x63, 0x48, 0x0F, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x8F, 0xD4, 0xBA, 0x34, 0xCD, 0x03, + 0xBB, 0xC2, 0x20, 0x2F, 0xA6, 0x38, 0xB0, 0x09, 0xAB, 0x8C, 0x50, 0xF4, 0xD3, 0x38, 0x0E, 0xE9, + 0xE8, 0x80, 0xC3, 0x18, 0xA3, 0xC4, 0xD1, 0xA9, 0x20, 0x1E, 0x43, 0x06, 0x83, 0x8D, 0x3C, 0x18, + 0x70, 0x21, 0x80, 0xAF, 0xB4, 0x9D, 0xAD, 0x13, 0x10, 0xB8, 0x00, 0xB7, 0x42, 0xF6, 0x59, 0x46, + 0x0A, 0x4A, 0xD0, 0xC8, 0x32, 0x82, 0xCC, 0xB4, 0x01, 0x0A, 0x14, 0xAD, 0x92, 0x82, 0x26, 0xA0, + 0x40, 0x24, 0x83, 0x00, 0xAE, 0x56, 0xFC, 0x3A, 0xAA, 0x4A, 0x61, 0x4F, 0x32, 0xAA, 0xAC, 0xDA, + 0x0C, 0x4F, 0xC8, 0xFB, 0x47, 0x5A, 0xEE, 0xD2, 0x9B, 0x2F, 0xB6, 0x71, 0x31, 0x32, 0xFE, 0x54, + 0x9A, 0xA3, 0xEF, 0xFD, 0xDD, 0xFC, 0xB2, 0x24, 0xCB, 0x70, 0x9D, 0xF9, 0x24, 0xF4, 0xC4, 0xCB, + 0xFB, 0x0D, 0xC3, 0xF0, 0xDC, 0x1E, 0xEF, 0x3B, 0x0B, 0x59, 0x51, 0x34, 0xB4, 0x55, 0x7D, 0xE7, + 0xDE, 0xDE, 0x33, 0x96, 0xD2, 0x05, 0x5C, 0xCA, 0xE9, 0x63, 0x36, 0x78, 0xAF, 0x43, 0x4A, 0xDF, + 0xF6, 0x0C, 0x0C, 0x05, 0x0A, 0x8E, 0x5C, 0x18, 0x44, 0x21, 0xBA, 0x60, 0x9D, 0x12, 0x9E, 0x8A, + 0xBF, 0xBA, 0xFF, 0xD4, 0x81, 0xA3, 0x85, 0xB8, 0x86, 0xC2, 0x5C, 0x32, 0x5E, 0xA6, 0xFF, 0xFD, + 0x4F, 0x41, 0x8C, 0x38, 0xCA, 0xFB, 0x0C, 0x81, 0x54, 0x7C, 0x90, 0x59, 0xCC, 0x9E, 0xC3, 0x20, + 0x89, 0x84, 0x54, 0x01, 0xBC, 0x45, 0x19, 0x82, 0x40, 0x79, 0x8A, 0xA8, 0xB1, 0xA9, 0x61, 0xB9, + 0x85, 0xC0, 0x89, 0x84, 0xA8, 0xB1, 0xAA, 0x25, 0x91, 0x8B, 0x26, 0x5B, 0xA3, 0xE1, 0x54, 0x0D, + 0x31, 0x0C, 0x40, 0x05, 0x09, 0xA8, 0x2B, 0x68, 0x63, 0x27, 0x9C, 0x09, 0x19, 0x2A, 0x36, 0x02, + 0x9A, 0x1A, 0x2C, 0x1F, 0x27, 0x68, 0xDF, 0x0A, 0x50, 0xA7, 0x12, 0xA1, 0x01, 0x0E, 0x50, 0xA5, + 0x32, 0x86, 0xF8, 0xE2, 0x08, 0x70, 0x63, 0x82, 0xBA, 0x56, 0x52, 0x31, 0x06, 0x3C, 0x66, 0x31, + 0xE2, 0x9E, 0x8C, 0xF8, 0xF5, 0x45, 0x21, 0x03, 0x78, 0xE9, 0x2F, 0xD0, 0x23, 0x2B, 0xED, 0x1A, + 0xDF, 0x38, 0x82, 0xC1, 0x10, 0xF3, 0xB3, 0x9A, 0x71, 0xD7, 0x5E, 0xF2, 0x32, 0x23, 0xE2, 0xB3, + 0xBF, 0x3B, 0x55, 0x4E, 0xD5, 0x4B, 0x48, 0x62, 0x61, 0x39, 0x16, 0xB2, 0x38, 0xBC, 0x3F, 0x36, + 0xF9, 0x0F, 0x6C, 0x8F, 0x80, 0x9B, 0x06, 0xF9, 0xB3, 0x7F, 0xD1, 0x7F, 0xC4, 0x89, 0xC4, 0x70, + 0x63, 0x33, 0x0B, 0x24, 0xBB, 0xCF, 0x71, 0xFB, 0xCC, 0x24, 0x6D, 0xFF, 0x3F, 0x02, 0xC2, 0x53, + 0x4C, 0x3A, 0x0E, 0x8D, 0x3F, 0xFF, 0xAF, 0x17, 0x85, 0xD1, 0xA0, 0x6C, 0x2F, 0xC8, 0xFA, 0x98, + 0x25, 0xBC, 0x60, 0x14, 0x65, 0x95, 0x02, 0x82, 0x80, 0x01, 0x24, 0xC7, 0xBC, 0xE0, 0xD8, 0xF5, + 0x04, 0xC2, 0xB1, 0x28, 0xC7, 0xE0, 0xEC, 0xE6, 0xF0, 0xF8, 0xC7, 0x30, 0xA0, 0xC3, 0x93, 0x48, + 0xE6, 0xC0, 0x54, 0xCD, 0x81, 0x8B, 0xE8, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8F, 0x24, 0xA5, 0x34, + 0xCD, 0x03, 0xBB, 0x7A, 0x70, 0x2F, 0x65, 0xE9, 0x81, 0x1D, 0x05, 0x6A, 0x91, 0xD0, 0xD1, 0x38, + 0x0F, 0x73, 0x42, 0x80, 0xCB, 0x97, 0xE6, 0xA0, 0x56, 0x0A, 0x18, 0x6E, 0x32, 0xA4, 0x4D, 0x68, + 0x1C, 0x6D, 0x45, 0xA4, 0xC8, 0xA9, 0x80, 0x5B, 0x96, 0xBD, 0x59, 0xD5, 0x55, 0x44, 0xCD, 0x7C, + 0x27, 0x9B, 0x89, 0x50, 0x05, 0xD7, 0x08, 0x1D, 0x2E, 0xCB, 0xD0, 0x5F, 0x15, 0xCE, 0x18, 0x82, + 0x92, 0xA9, 0x20, 0x4A, 0x14, 0x34, 0x5C, 0xAC, 0xC8, 0x3C, 0x80, 0xBB, 0x7A, 0x43, 0x99, 0xBE, + 0x71, 0x2C, 0x0F, 0xB1, 0xD8, 0x06, 0x73, 0x8C, 0xAD, 0x30, 0x54, 0xA3, 0x78, 0xBD, 0x12, 0x83, + 0xFD, 0xC1, 0xC9, 0x52, 0xAD, 0xCE, 0xBB, 0x6A, 0xD2, 0x1C, 0xA9, 0xD2, 0x7D, 0x70, 0xB9, 0x38, + 0xEB, 0x89, 0x66, 0xB2, 0x40, 0xBB, 0xC7, 0x1F, 0x62, 0x42, 0x78, 0x43, 0x34, 0x54, 0x4E, 0x95, + 0x65, 0xE1, 0xAD, 0x3F, 0xB5, 0xC2, 0xCA, 0xA1, 0x42, 0xB9, 0x54, 0xA2, 0xEA, 0xA0, 0xC8, 0x10, + 0x04, 0xC0, 0x2C, 0x37, 0xFE, 0x2B, 0x25, 0xF9, 0x64, 0x25, 0x61, 0xDB, 0xC2, 0x20, 0xB8, 0xB8, + 0xBB, 0x2D, 0xD6, 0x0E, 0x06, 0xC6, 0x87, 0xEE, 0x0A, 0xCF, 0xD1, 0x1B, 0x57, 0x91, 0x22, 0x4E, + 0xF3, 0xD6, 0xDD, 0x1B, 0xFE, 0x77, 0xF5, 0x08, 0x07, 0xDF, 0xE1, 0xE0, 0xE7, 0x90, 0x4B, 0xA0, + 0x80, 0x45, 0x30, 0x4F, 0x09, 0x63, 0x44, 0xD0, 0x89, 0x33, 0x48, 0xE8, 0x60, 0x6E, 0x7F, 0xC4, + 0x30, 0x88, 0x7A, 0x38, 0x15, 0x37, 0x2B, 0x18, 0xDB, 0x05, 0x31, 0x24, 0x4C, 0xA6, 0x70, 0xCC, + 0xE2, 0x85, 0x0D, 0x41, 0xB0, 0x08, 0x55, 0x03, 0x6B, 0xEE, 0x7D, 0x1C, 0x1E, 0xDD, 0x9F, 0xE5, + 0xEB, 0x3B, 0x00, 0xAE, 0x59, 0x10, 0xB0, 0x34, 0x1F, 0x58, 0x83, 0x40, 0x91, 0xF0, 0x78, 0x81, + 0x7F, 0x40, 0xC7, 0x02, 0x83, 0x04, 0x21, 0x04, 0x22, 0x40, 0xA0, 0xD9, 0x95, 0xA9, 0x43, 0x0C, + 0x6E, 0xCE, 0x82, 0xEC, 0x7C, 0x9C, 0x56, 0x64, 0xFA, 0x3F, 0x91, 0x4B, 0xF0, 0xEC, 0x47, 0x73, + 0xBD, 0xA0, 0x93, 0x53, 0x7F, 0xFE, 0xDC, 0x19, 0x74, 0x7A, 0xD4, 0x62, 0x4B, 0x1F, 0x97, 0x77, + 0x7B, 0xF8, 0xED, 0x78, 0x1E, 0x72, 0x7F, 0x06, 0x0E, 0xE4, 0xB7, 0x18, 0x7A, 0x00, 0x7D, 0xA4, + 0x50, 0x25, 0x37, 0x68, 0x27, 0x5E, 0xBB, 0x34, 0xB0, 0xEC, 0x7B, 0x52, 0xD4, 0x00, 0x03, 0x00, + 0x1D, 0x12, 0x4F, 0xF0, 0xB1, 0x4F, 0x12, 0x41, 0x5A, 0x87, 0x22, 0x42, 0xD8, 0x50, 0xD2, 0xAC, + 0x5D, 0x24, 0x88, 0x66, 0x5E, 0x7A, 0x1A, 0x41, 0x1B, 0x0F, 0x3C, 0xC7, 0xBC, 0xC0, 0x9E, 0xC6, + 0x10, 0x8E, 0x86, 0x5F, 0x62, 0x12, 0x8F, 0x39, 0xEC, 0xFF, 0x87, 0x11, 0xF0, 0x41, 0x7D, 0x6A, + 0x48, 0xD0, 0x68, 0x34, 0x08, 0x43, 0xCC, 0x40, 0x76, 0x8C, 0x1E, 0x02, 0xCC, 0x0F, 0x17, 0x8D, + 0x1F, 0x8E, 0x0D, 0x40, 0x2B, 0x0C, 0x94, 0x80, 0xE8, 0xFF, 0xFB, 0x92, 0x64, 0x0C, 0x8F, 0x94, + 0x44, 0x33, 0xCE, 0x83, 0xBB, 0xC1, 0xA0, 0x30, 0x05, 0xB9, 0x75, 0x15, 0x02, 0x8C, 0xD1, 0xD0, + 0xCF, 0x34, 0x0E, 0xE9, 0xEB, 0xC0, 0xB4, 0x99, 0x64, 0xD8, 0x06, 0xAE, 0x1B, 0x91, 0xCF, 0x58, + 0x38, 0x04, 0x0C, 0x60, 0x83, 0x67, 0x04, 0x60, 0x9D, 0x0B, 0xCD, 0x29, 0x01, 0x43, 0x79, 0xE0, + 0x74, 0xC4, 0xAB, 0x42, 0x0D, 0x81, 0x12, 0x20, 0xBB, 0x85, 0xAF, 0x6B, 0xEA, 0xC0, 0x22, 0x28, + 0x38, 0x68, 0x12, 0x15, 0xF0, 0xB6, 0x13, 0x05, 0x3F, 0x01, 0x27, 0x72, 0xA4, 0x64, 0x00, 0x60, + 0xBF, 0x92, 0x99, 0xD0, 0xB7, 0x8A, 0xAE, 0xE6, 0x47, 0xD4, 0x4D, 0xEB, 0x6B, 0xF3, 0x4A, 0x51, + 0x18, 0x94, 0x42, 0xE8, 0x39, 0x5B, 0xBF, 0xFF, 0xFA, 0xCE, 0x1F, 0x61, 0xDC, 0xA0, 0x94, 0x63, + 0x6A, 0xF5, 0x4E, 0xFD, 0xD7, 0x6A, 0x82, 0x39, 0x2E, 0xAC, 0xFA, 0x3A, 0x2A, 0xF3, 0xAE, 0xF6, + 0x0D, 0xD9, 0xCD, 0x84, 0x6E, 0xB5, 0xE9, 0xCD, 0x38, 0xEF, 0xBB, 0xFD, 0xD0, 0x10, 0x00, 0x65, + 0xFF, 0x08, 0x81, 0x7A, 0xE6, 0xE5, 0x1A, 0xD6, 0x54, 0x60, 0x3E, 0xC2, 0x41, 0xF2, 0xBA, 0xAA, + 0xFE, 0xA9, 0xFB, 0x5F, 0xF1, 0x0E, 0x50, 0xCA, 0xF5, 0xFF, 0x36, 0x03, 0xA0, 0xF4, 0x5F, 0x28, + 0xFB, 0x89, 0x8E, 0x63, 0xC2, 0xB4, 0x20, 0x91, 0xB8, 0x77, 0xD8, 0x48, 0x86, 0x92, 0x0D, 0x00, + 0x41, 0xC5, 0xB9, 0xB3, 0x16, 0x28, 0x20, 0x09, 0x30, 0x0C, 0x2D, 0x32, 0xE6, 0x0D, 0x0D, 0xA8, + 0x0C, 0x12, 0x03, 0x4C, 0x71, 0x19, 0x4C, 0x65, 0x17, 0x92, 0x68, 0xCF, 0xEA, 0x3D, 0x69, 0x85, + 0x0A, 0x0E, 0xA4, 0x01, 0x1E, 0x3E, 0x29, 0x55, 0xEC, 0x90, 0x1C, 0x3D, 0x82, 0x3C, 0x65, 0xA9, + 0x26, 0xE9, 0xEF, 0x80, 0x11, 0x94, 0x8A, 0x88, 0x2A, 0x3C, 0x6D, 0xB3, 0x4F, 0x21, 0x08, 0x78, + 0x5A, 0x19, 0x80, 0xE5, 0xDC, 0x30, 0x33, 0x44, 0xF3, 0x33, 0x95, 0x9B, 0x41, 0xF7, 0xC1, 0x81, + 0xD8, 0x2E, 0x2E, 0x68, 0x38, 0xCB, 0xA7, 0x3C, 0xBE, 0x58, 0x7A, 0xC1, 0x59, 0x3A, 0x0B, 0x6B, + 0x19, 0x47, 0x36, 0xFD, 0xFF, 0xFE, 0x18, 0x54, 0x94, 0x48, 0x79, 0x8E, 0x35, 0x11, 0xAC, 0xAC, + 0x8F, 0x7F, 0x4C, 0xC1, 0x4E, 0xC9, 0x0D, 0x74, 0x10, 0x91, 0xDA, 0x41, 0x5E, 0x8B, 0x29, 0xAE, + 0x64, 0xCA, 0x8B, 0xA4, 0x93, 0xE9, 0xBD, 0x16, 0x4A, 0xD3, 0xFA, 0x11, 0x01, 0xBF, 0x95, 0x08, + 0xD0, 0x38, 0xC6, 0xCF, 0xA3, 0xDD, 0x7F, 0xE3, 0xE4, 0xDE, 0xD3, 0x10, 0x34, 0xDB, 0xE1, 0xD1, + 0xF0, 0xE7, 0x38, 0xA8, 0xB9, 0xDD, 0x35, 0xBB, 0xF6, 0x9A, 0xF3, 0xFD, 0x69, 0x03, 0x6D, 0xC7, + 0xB0, 0xF7, 0x7E, 0x90, 0xFA, 0x40, 0x0D, 0x4A, 0x55, 0x97, 0x08, 0x00, 0xF3, 0x09, 0x0D, 0x53, + 0x6F, 0xEA, 0x83, 0x14, 0x82, 0x13, 0x14, 0x00, 0x93, 0x09, 0x7A, 0x93, 0xC2, 0x06, 0xB1, 0xE2, + 0x24, 0xC2, 0x31, 0xDC, 0xD1, 0x02, 0x20, 0xC1, 0x40, 0x0C, 0xC5, 0xFF, 0xFB, 0x92, 0x64, 0x11, + 0x07, 0xA4, 0x9D, 0x33, 0x4D, 0x03, 0xBA, 0xC2, 0xE0, 0x30, 0x46, 0x69, 0x58, 0x08, 0xC7, 0xC0, + 0x11, 0x5C, 0xCF, 0x36, 0xAE, 0xE5, 0xEB, 0x90, 0xBF, 0x99, 0xA6, 0xC8, 0x13, 0x0D, 0x78, 0xB5, + 0x34, 0x53, 0x42, 0x12, 0x1A, 0x00, 0x40, 0x82, 0x26, 0x9A, 0xD3, 0x28, 0x7F, 0x47, 0x19, 0xBA, + 0x77, 0xE0, 0x50, 0x28, 0x97, 0xA9, 0x9E, 0x19, 0x90, 0x83, 0x41, 0x1D, 0x60, 0xB1, 0x93, 0x20, + 0xD9, 0x56, 0x30, 0xB3, 0x28, 0x85, 0x1E, 0x99, 0x60, 0xC5, 0x73, 0x22, 0x21, 0x58, 0x69, 0x28, + 0x67, 0xF6, 0xAA, 0xD2, 0xCB, 0x44, 0x26, 0x31, 0x81, 0x68, 0x2B, 0x4B, 0xFA, 0x5F, 0x2A, 0x67, + 0x29, 0x9E, 0xDB, 0x67, 0x14, 0xEE, 0x9D, 0xFD, 0xC1, 0x78, 0x73, 0xF7, 0xCA, 0xC1, 0xDB, 0x6A, + 0x70, 0x73, 0xC4, 0xE2, 0x49, 0x6C, 0x37, 0x9A, 0xE6, 0x31, 0xE8, 0x72, 0xDB, 0x11, 0x9A, 0x75, + 0xA0, 0xAD, 0x5A, 0x95, 0xB1, 0xDA, 0x39, 0x53, 0x85, 0xCD, 0x61, 0x8C, 0x13, 0x36, 0xAD, 0x90, + 0x30, 0x00, 0x01, 0x00, 0x40, 0x71, 0xFF, 0xF9, 0x0A, 0x06, 0x2F, 0xCE, 0xFE, 0x42, 0x5C, 0x28, + 0x92, 0x81, 0xB9, 0xD1, 0xA8, 0xDF, 0xB4, 0x40, 0x40, 0x38, 0xF4, 0x8C, 0xB9, 0x36, 0xAE, 0xDF, + 0xA2, 0x6F, 0xA9, 0xF4, 0xA0, 0xD1, 0x9C, 0x71, 0x8C, 0x9A, 0x86, 0x0A, 0x42, 0xDE, 0x2E, 0x23, + 0x2D, 0x03, 0xDA, 0x90, 0x46, 0x1F, 0x04, 0x07, 0x0E, 0x40, 0x26, 0x1C, 0x03, 0x86, 0x28, 0x09, + 0x66, 0x14, 0x77, 0xA7, 0x44, 0x02, 0x46, 0x2B, 0x02, 0xC1, 0x80, 0x19, 0xAC, 0x23, 0x88, 0x08, + 0x0F, 0x38, 0xA1, 0x35, 0x40, 0x0B, 0x18, 0x15, 0x26, 0x24, 0x64, 0x7A, 0xFC, 0x41, 0x42, 0x8D, + 0x91, 0x37, 0x5E, 0x34, 0x6A, 0x0D, 0x34, 0xED, 0x02, 0x01, 0x22, 0x26, 0xDA, 0x98, 0x1B, 0x5C, + 0xC6, 0x2B, 0x85, 0x8B, 0x54, 0x52, 0x50, 0xA0, 0xA6, 0x90, 0x31, 0x98, 0xD0, 0xB0, 0x8E, 0x74, + 0x55, 0xBF, 0xBD, 0x0F, 0x44, 0xA8, 0x2D, 0x42, 0x14, 0x1C, 0x82, 0xD0, 0x59, 0xA6, 0xC9, 0xEA, + 0x81, 0x13, 0x0C, 0xDC, 0xB5, 0xCF, 0x55, 0x9D, 0x7F, 0x75, 0xC8, 0x47, 0x4B, 0xD3, 0x0A, 0xF2, + 0x6E, 0x34, 0x04, 0x43, 0x86, 0x58, 0xDF, 0x30, 0xB1, 0x29, 0xA3, 0x1D, 0x09, 0xB2, 0xBF, 0x78, + 0x34, 0x9F, 0x3F, 0x50, 0xD7, 0x29, 0xF7, 0x24, 0xED, 0x1B, 0x22, 0x6C, 0xC0, 0x28, 0xFF, 0xFE, + 0x86, 0x1A, 0x3F, 0x7B, 0x29, 0xF7, 0xDE, 0x96, 0x08, 0x8F, 0xFF, 0xB8, 0x21, 0x03, 0x0F, 0x27, + 0xD3, 0xD8, 0xF7, 0xF9, 0x41, 0x17, 0x5D, 0xEC, 0xF7, 0x84, 0xEE, 0x7B, 0x17, 0xFD, 0x77, 0x99, + 0x7D, 0x3F, 0xC9, 0x67, 0x0C, 0xB3, 0x9D, 0x07, 0xF6, 0x2E, 0x20, 0x42, 0x2E, 0xD1, 0x80, 0x80, + 0x88, 0xF1, 0xDC, 0x6F, 0x9B, 0x34, 0x60, 0x88, 0xC0, 0x62, 0x28, 0x06, 0x63, 0x47, 0x5A, 0x70, + 0xC0, 0xA6, 0x61, 0x80, 0x7C, 0x61, 0x19, 0x18, 0x6A, 0x21, 0xB4, 0x50, 0x03, 0xFF, 0xFB, 0x92, + 0x64, 0x10, 0x8F, 0x64, 0x68, 0x33, 0x4D, 0x83, 0xB9, 0x7A, 0xF0, 0x2E, 0xE6, 0x69, 0xD1, 0x09, + 0x22, 0x5E, 0x92, 0x94, 0xCF, 0x36, 0x0F, 0x73, 0x46, 0x40, 0xA7, 0x16, 0xA7, 0x20, 0x53, 0x0A, + 0xCA, 0x1D, 0x6D, 0x9F, 0xE3, 0x82, 0x02, 0x37, 0xF7, 0x16, 0x5C, 0xFB, 0x80, 0xBE, 0x12, 0xD0, + 0x69, 0x63, 0xCB, 0x41, 0xAA, 0xC4, 0x62, 0x83, 0x72, 0xE0, 0xEA, 0x2F, 0x2C, 0xDA, 0x93, 0x3F, + 0xC6, 0x6A, 0x50, 0x00, 0x91, 0x0C, 0x7A, 0x65, 0x9D, 0x84, 0xBD, 0x1C, 0x61, 0x89, 0xDC, 0xEF, + 0x2D, 0xA5, 0x60, 0x90, 0x74, 0x2A, 0x08, 0x14, 0xF5, 0xC9, 0x21, 0x76, 0x94, 0xDE, 0x1D, 0x6B, + 0xA4, 0x1E, 0x93, 0x9C, 0x8D, 0x51, 0x72, 0x9C, 0x59, 0x8F, 0xF1, 0x11, 0x58, 0x87, 0x13, 0x67, + 0xD1, 0x2F, 0x59, 0x0B, 0x1A, 0xCF, 0x82, 0xA7, 0x59, 0xAD, 0x64, 0x55, 0x05, 0xF8, 0xFC, 0x4B, + 0xA5, 0xCF, 0xC6, 0xE7, 0x68, 0x4E, 0xF9, 0xFA, 0x73, 0x2A, 0x2C, 0x78, 0xBA, 0x02, 0x07, 0x01, + 0x15, 0xFF, 0xE5, 0xCF, 0x1C, 0x0D, 0x4F, 0x3B, 0x77, 0xE8, 0xC1, 0xAA, 0x56, 0xB7, 0xFF, 0x48, + 0x72, 0xE0, 0x95, 0xA2, 0x4E, 0x95, 0xFF, 0x99, 0x54, 0xC2, 0x3C, 0xF2, 0xA0, 0x43, 0xB1, 0x8A, + 0xFF, 0xEC, 0xE6, 0xF6, 0xF7, 0xF2, 0xD6, 0xC7, 0x6D, 0x65, 0x48, 0xCA, 0xF1, 0x21, 0x99, 0x83, + 0xD0, 0x1F, 0x99, 0x3F, 0x07, 0x39, 0x81, 0xD0, 0x06, 0x16, 0x00, 0x34, 0xC1, 0x8D, 0x1E, 0xCC, + 0x02, 0x42, 0x6C, 0xC3, 0xA4, 0x83, 0x5B, 0x0F, 0x4E, 0x4E, 0x99, 0x12, 0x19, 0x83, 0x94, 0x1A, + 0xDC, 0xA6, 0x2C, 0x18, 0xF0, 0x23, 0x3E, 0x04, 0x24, 0xEB, 0xDC, 0xA0, 0x26, 0x10, 0x13, 0xAD, + 0x36, 0x96, 0x80, 0xE0, 0x51, 0xD8, 0x04, 0xA0, 0xA3, 0x7F, 0x2A, 0x00, 0x11, 0x2B, 0x33, 0x02, + 0xBF, 0xE0, 0x60, 0x52, 0x87, 0xA0, 0x30, 0xC1, 0x40, 0x29, 0x6A, 0x3D, 0x30, 0x89, 0x03, 0x65, + 0x11, 0x00, 0xA0, 0x15, 0x06, 0x61, 0x51, 0xAB, 0x13, 0x8C, 0x5E, 0x50, 0x32, 0x27, 0x61, 0x91, + 0xAB, 0x4A, 0x97, 0x50, 0xB1, 0x74, 0xBB, 0x84, 0xD1, 0x6E, 0x7A, 0x53, 0x6B, 0xE6, 0x1E, 0x09, + 0x0B, 0xB5, 0x12, 0x76, 0x37, 0xDB, 0x18, 0xBC, 0xFD, 0xEE, 0xA6, 0x2D, 0xFF, 0xE9, 0xAA, 0xB8, + 0xAB, 0x90, 0x88, 0x23, 0xDD, 0x04, 0xB9, 0x79, 0x53, 0x73, 0x59, 0x41, 0x57, 0x6B, 0xFB, 0xF1, + 0xC6, 0x00, 0x00, 0x88, 0x18, 0xED, 0xFF, 0x11, 0x15, 0xA8, 0x23, 0x56, 0x54, 0x8B, 0x29, 0x3C, + 0x2F, 0xF2, 0x4D, 0x07, 0x4E, 0x8A, 0x5B, 0xD9, 0x43, 0x0D, 0x3F, 0x71, 0x93, 0x91, 0xA6, 0xFD, + 0x4F, 0x23, 0x29, 0x2F, 0xF5, 0xFD, 0x45, 0xC9, 0xEB, 0x7A, 0x6A, 0x7C, 0x13, 0x78, 0xC5, 0x12, + 0xC8, 0xEE, 0x12, 0xC4, 0xC4, 0x50, 0x18, 0xC6, 0xB0, 0x54, 0xDC, 0x6A, 0x34, 0xDB, 0x91, 0x04, + 0xC3, 0xA0, 0xE8, 0xCB, 0x94, 0x98, 0xDF, 0x70, 0x00, 0xC1, 0x90, 0x6C, 0xC5, 0x81, 0xD0, 0xFF, + 0xFB, 0x92, 0x64, 0x12, 0x07, 0xB4, 0xAA, 0x33, 0xCD, 0x03, 0xBA, 0x7B, 0x60, 0x2C, 0xE6, 0x39, + 0xE4, 0x04, 0x02, 0x08, 0xD1, 0x8C, 0xD1, 0x38, 0xAE, 0xE9, 0xED, 0x80, 0xBF, 0x97, 0x26, 0x40, + 0x24, 0x8A, 0x58, 0xC8, 0x24, 0x98, 0x1A, 0x0D, 0x83, 0x1E, 0x19, 0x19, 0x66, 0x98, 0x59, 0x6D, + 0x8B, 0x90, 0x11, 0x06, 0xA4, 0x32, 0x17, 0x69, 0x4F, 0x19, 0x67, 0xA8, 0x6A, 0xDB, 0x37, 0x33, + 0x46, 0x30, 0x68, 0x73, 0xE8, 0x1C, 0x91, 0xD7, 0x7E, 0x50, 0xEC, 0x59, 0xC8, 0x39, 0xB1, 0xA1, + 0x99, 0x7F, 0x15, 0xA5, 0x3B, 0xDB, 0x83, 0xF4, 0x28, 0x6C, 0x10, 0x79, 0x35, 0xD3, 0xD8, 0x05, + 0x31, 0x12, 0xDA, 0x18, 0xE8, 0xF7, 0x15, 0x3A, 0xF4, 0x3B, 0x1B, 0x73, 0x12, 0x0B, 0xC6, 0xCB, + 0x6A, 0x11, 0xCE, 0x95, 0x82, 0x40, 0x1C, 0xA0, 0x35, 0x38, 0xE6, 0x19, 0x69, 0xBC, 0x19, 0x88, + 0x0F, 0x87, 0xC7, 0xE9, 0x31, 0x0A, 0xA1, 0xCE, 0xE4, 0xB4, 0x1D, 0x2E, 0xAB, 0xAF, 0xCD, 0x85, + 0xA8, 0x2A, 0xC9, 0x5A, 0x00, 0x00, 0x08, 0x00, 0x07, 0x45, 0xE0, 0x4E, 0x45, 0xE8, 0xF1, 0xB4, + 0x21, 0x03, 0xE8, 0x57, 0x84, 0x06, 0x72, 0x02, 0x31, 0x06, 0x18, 0xA0, 0x85, 0x05, 0x0C, 0x11, + 0x0D, 0x50, 0x4D, 0xDA, 0xAC, 0xE6, 0xE8, 0xEA, 0x8D, 0xAB, 0xE6, 0xA1, 0x5D, 0xD5, 0x3E, 0x09, + 0xD2, 0xC0, 0xB5, 0x4B, 0xBC, 0x60, 0x29, 0x4E, 0x6C, 0x82, 0xBC, 0x60, 0x60, 0x72, 0x62, 0x09, + 0x04, 0x66, 0x86, 0xC4, 0x67, 0x18, 0x58, 0x60, 0x10, 0x0C, 0x62, 0x42, 0x2A, 0x67, 0x68, 0x1A, + 0x8F, 0x88, 0x46, 0x63, 0x3A, 0xCE, 0x61, 0x48, 0x0A, 0x24, 0x40, 0xC2, 0xD7, 0x30, 0xA4, 0xD9, + 0xC2, 0x1E, 0x02, 0x8F, 0xC5, 0xB6, 0x22, 0x4B, 0x6F, 0xAE, 0xE3, 0x24, 0x91, 0xB3, 0x10, 0x30, + 0xC9, 0x1B, 0xE0, 0x17, 0x30, 0xD6, 0x28, 0xD8, 0x52, 0x52, 0x4E, 0xB8, 0x6D, 0x11, 0x0C, 0xDE, + 0x55, 0xA3, 0x21, 0x8D, 0x37, 0xA4, 0xD1, 0x52, 0xE2, 0x2E, 0x66, 0xC2, 0xB6, 0x09, 0x94, 0x19, + 0x6A, 0xCC, 0xC7, 0xA1, 0x61, 0x54, 0x31, 0x9F, 0xF1, 0xE2, 0xA4, 0x1F, 0xEB, 0xC2, 0x9A, 0xB0, + 0xE4, 0xD3, 0x75, 0xF6, 0xD4, 0x93, 0x77, 0xD4, 0xCF, 0xFF, 0x48, 0xCE, 0x93, 0x0B, 0xD5, 0x43, + 0x00, 0x82, 0x92, 0xD5, 0x7F, 0xCE, 0xE8, 0xC5, 0x34, 0x06, 0xE2, 0xF6, 0xCF, 0x41, 0xBF, 0xF2, + 0x13, 0xA8, 0x20, 0x40, 0x3E, 0x83, 0xA5, 0x1D, 0x51, 0x1A, 0x12, 0x61, 0x36, 0xF5, 0xD5, 0x87, + 0x91, 0x68, 0xDE, 0x44, 0xA8, 0xDE, 0x7F, 0x99, 0xD5, 0x1A, 0x14, 0xE5, 0x6B, 0x8A, 0x2B, 0xAB, + 0x36, 0x26, 0x9A, 0x5F, 0xEC, 0x55, 0x76, 0x14, 0x38, 0x06, 0x59, 0x81, 0x62, 0x55, 0x7A, 0x10, + 0x6C, 0xC3, 0x82, 0xC0, 0xC1, 0x85, 0xAC, 0x50, 0x05, 0x30, 0xF8, 0x56, 0x34, 0x8E, 0x18, 0x35, + 0x28, 0x88, 0x30, 0x70, 0x19, 0x92, 0x98, 0xA2, 0x3E, 0x15, 0x00, 0x90, 0x82, 0x9C, 0xD2, 0x49, + 0x90, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x87, 0x34, 0x5B, 0x34, 0x4E, 0x03, 0xB9, 0x7B, 0x60, 0x2F, + 0xA5, 0xD9, 0x98, 0x1C, 0xC2, 0x96, 0x92, 0x00, 0xD3, 0x38, 0xAE, 0x69, 0xED, 0x90, 0xC3, 0x1A, + 0x26, 0xD0, 0x73, 0x16, 0x50, 0xC6, 0xC0, 0x58, 0x24, 0xF3, 0x60, 0xB3, 0xC4, 0x55, 0x35, 0x99, + 0x01, 0x2D, 0x2A, 0x78, 0x8C, 0x26, 0xA0, 0x09, 0xC7, 0xD9, 0x11, 0x65, 0x8F, 0xA0, 0x58, 0xF7, + 0xBA, 0x18, 0x10, 0x92, 0x3C, 0x66, 0xF0, 0x2C, 0xDA, 0xFC, 0x80, 0xCB, 0x00, 0x05, 0x01, 0x6A, + 0x70, 0xF1, 0xBA, 0x0D, 0xD8, 0x08, 0x18, 0xD9, 0x6E, 0x90, 0xDD, 0xA2, 0x86, 0x0F, 0x51, 0xEA, + 0x5F, 0x8A, 0x36, 0x20, 0xED, 0x46, 0x39, 0x30, 0xA3, 0x9C, 0x36, 0xBF, 0xFD, 0x27, 0xCC, 0x1D, + 0xE6, 0x47, 0x2C, 0x60, 0xDE, 0x8D, 0x96, 0xC6, 0xCC, 0x69, 0xB1, 0x18, 0xC8, 0x08, 0xD2, 0xAD, + 0x52, 0x93, 0x09, 0x43, 0x77, 0xF4, 0x5B, 0xBB, 0x2B, 0xAC, 0x18, 0x08, 0x37, 0xE0, 0x40, 0x00, + 0x00, 0x05, 0x3E, 0xFE, 0x06, 0x03, 0x3A, 0xB5, 0x3D, 0x1F, 0x4C, 0x40, 0xAE, 0xCE, 0x8E, 0xF3, + 0x4F, 0x42, 0x03, 0x1B, 0x84, 0xFF, 0x29, 0x2D, 0x7D, 0x31, 0x0F, 0x0A, 0xEA, 0x2F, 0x08, 0xC8, + 0x4F, 0xFA, 0x12, 0xEF, 0x6F, 0x65, 0x0E, 0x66, 0x0A, 0x1F, 0x69, 0x77, 0x13, 0x81, 0x95, 0x07, + 0x00, 0x4C, 0x8E, 0x07, 0x3B, 0x8C, 0xD0, 0x98, 0x2C, 0x1C, 0xD1, 0x36, 0x8E, 0x94, 0xF7, 0xC6, + 0x33, 0x27, 0x94, 0x4C, 0x8C, 0x7D, 0x3A, 0xB2, 0x30, 0x88, 0x60, 0x67, 0x63, 0x21, 0xF2, 0xE5, + 0x67, 0x20, 0x01, 0x04, 0xD7, 0x19, 0x1C, 0x3D, 0x79, 0x64, 0xCE, 0x0F, 0x28, 0x56, 0x88, 0xF1, + 0x81, 0x34, 0x18, 0x52, 0x5A, 0xF8, 0xAF, 0xB6, 0xAC, 0xFB, 0x15, 0x41, 0x34, 0x67, 0x11, 0x60, + 0x42, 0x18, 0x3D, 0x93, 0x41, 0x80, 0x0B, 0x83, 0x9C, 0x38, 0x60, 0x87, 0x3C, 0xE9, 0xFE, 0x04, + 0x28, 0xDF, 0xBE, 0x83, 0x92, 0x1B, 0x2B, 0x82, 0xA1, 0xA1, 0x88, 0xAA, 0xBF, 0xE9, 0xA4, 0x41, + 0x13, 0x82, 0x62, 0x2C, 0x11, 0x79, 0x4C, 0xCB, 0x7D, 0x6F, 0xC0, 0x9E, 0xAD, 0xF8, 0x54, 0x6A, + 0x75, 0x7E, 0xDF, 0x5E, 0x90, 0x91, 0xAD, 0x51, 0x61, 0x1D, 0x6E, 0x07, 0x50, 0xEE, 0x88, 0xD6, + 0x87, 0x28, 0xEF, 0xE1, 0xA5, 0xF6, 0x76, 0x4D, 0x85, 0xD0, 0x46, 0xD3, 0x76, 0x00, 0x40, 0x05, + 0x6C, 0x18, 0xDE, 0xFE, 0x20, 0x2B, 0xD7, 0x5F, 0x4D, 0xB5, 0x9E, 0x19, 0x08, 0x02, 0x87, 0xE4, + 0x89, 0x28, 0xF4, 0x7C, 0x6F, 0x86, 0x07, 0x03, 0xC2, 0xF3, 0x12, 0x30, 0x1A, 0x82, 0x34, 0x2F, + 0xFD, 0x0F, 0xEE, 0x0F, 0x6C, 0x44, 0x40, 0x7C, 0x4C, 0x3B, 0xF1, 0x9D, 0x45, 0x19, 0xC0, 0x00, + 0x00, 0x00, 0x6E, 0x8A, 0x8C, 0xC2, 0x80, 0xB4, 0xCF, 0x42, 0x4C, 0xC1, 0x40, 0x00, 0xC4, 0x60, + 0x6C, 0xC2, 0xE8, 0x44, 0xD2, 0x62, 0x34, 0x30, 0xFA, 0x31, 0xFC, 0x96, 0x32, 0x8C, 0xB5, 0x01, + 0x00, 0x06, 0x1B, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x87, 0x94, 0x90, 0x34, 0x4E, 0xC3, 0xB9, 0x4B, + 0x70, 0x31, 0x83, 0x79, 0x94, 0x14, 0x09, 0x60, 0x11, 0x40, 0xD3, 0x3C, 0xAE, 0xE5, 0x2D, 0xD0, + 0xBE, 0x8D, 0xA7, 0x30, 0x60, 0xA4, 0x30, 0x89, 0x66, 0x4B, 0x6D, 0x66, 0xD3, 0x14, 0x84, 0x26, + 0x85, 0x09, 0x2F, 0xDB, 0x29, 0x66, 0x4E, 0x18, 0xF1, 0x0D, 0xD5, 0x46, 0x83, 0x89, 0x7F, 0x32, + 0x65, 0x4E, 0x2C, 0xAC, 0x2A, 0x12, 0x71, 0xB7, 0x04, 0xF4, 0x10, 0x1B, 0x3B, 0x2A, 0x5E, 0xCA, + 0xC0, 0xF0, 0x29, 0x62, 0x76, 0xC5, 0x1B, 0x8C, 0x08, 0x65, 0x92, 0xD2, 0xC5, 0x58, 0x3B, 0xCF, + 0x16, 0xAD, 0xBB, 0x85, 0x01, 0xA1, 0x71, 0xA9, 0xD9, 0x2B, 0x3E, 0xAA, 0x55, 0x0D, 0xBA, 0x52, + 0x3A, 0x2B, 0xB2, 0x8E, 0xB5, 0xBF, 0x45, 0x96, 0x0E, 0x9F, 0x1D, 0x2A, 0xB8, 0x1F, 0xBF, 0xFB, + 0x15, 0x83, 0xA8, 0x2C, 0x15, 0x30, 0x80, 0x89, 0xC7, 0x48, 0x52, 0x4B, 0x0E, 0x9A, 0x49, 0xD3, + 0xE0, 0xF0, 0xA4, 0x14, 0x00, 0x50, 0x00, 0x00, 0x27, 0xCD, 0xE2, 0x40, 0x67, 0xD1, 0x4F, 0xD0, + 0xAE, 0x27, 0xD7, 0x6B, 0x7E, 0x0A, 0x93, 0xB6, 0x57, 0x66, 0x51, 0x05, 0xAE, 0xA3, 0x48, 0x38, + 0x28, 0x39, 0x10, 0x5C, 0xD8, 0x78, 0x70, 0x90, 0xE4, 0xCE, 0xE7, 0x84, 0x5F, 0x3D, 0x2A, 0x7B, + 0x49, 0x51, 0x2E, 0x22, 0x50, 0xC8, 0x1A, 0x6A, 0xE2, 0x30, 0x04, 0x4A, 0x33, 0xBC, 0x48, 0x08, + 0x0A, 0x0C, 0x5B, 0x03, 0x4C, 0x0C, 0x4E, 0xCD, 0x10, 0x1A, 0xCC, 0x91, 0x08, 0x4C, 0x3E, 0x17, + 0xCC, 0x9E, 0x38, 0x03, 0x01, 0x11, 0x40, 0x54, 0xC4, 0xC4, 0x34, 0xF9, 0x41, 0x1C, 0x1C, 0x18, + 0x61, 0x66, 0x55, 0x27, 0x10, 0xCC, 0xBE, 0x02, 0x13, 0x21, 0x83, 0x3C, 0xC0, 0xD8, 0x86, 0x9C, + 0x9E, 0x92, 0x97, 0xFD, 0x79, 0x47, 0x46, 0x48, 0x2F, 0xBB, 0x60, 0x78, 0x56, 0x53, 0xB4, 0xDA, + 0x98, 0xE3, 0x33, 0xA6, 0xF1, 0x29, 0x52, 0xB1, 0x7F, 0xBD, 0x4C, 0x68, 0x89, 0x65, 0x82, 0x24, + 0x1C, 0xD2, 0x31, 0xA0, 0xB4, 0x46, 0x5A, 0xC9, 0x1D, 0xF7, 0xCD, 0xF7, 0x7E, 0x69, 0x61, 0x98, + 0xE4, 0x62, 0x1D, 0xA3, 0xE7, 0xFF, 0xF4, 0x76, 0x27, 0x95, 0x26, 0x45, 0xFF, 0xBB, 0x40, 0xE6, + 0x39, 0xD0, 0x7E, 0xD1, 0x6E, 0x3D, 0xC9, 0x39, 0x37, 0xF9, 0xC1, 0x81, 0x01, 0x18, 0x21, 0x1E, + 0x00, 0x00, 0x19, 0x31, 0xE0, 0xFF, 0xE7, 0x91, 0x3B, 0x6B, 0xEA, 0x6A, 0x1A, 0x22, 0x30, 0xDA, + 0x13, 0x04, 0xE9, 0x24, 0xA9, 0x78, 0x28, 0x05, 0xC8, 0x4A, 0x59, 0x55, 0xCD, 0xC1, 0x61, 0xCC, + 0x32, 0x8B, 0x0C, 0x11, 0x13, 0x81, 0xD1, 0x21, 0xF6, 0xF7, 0x1F, 0xF5, 0xBF, 0x24, 0xA7, 0x2A, + 0xC0, 0x00, 0x00, 0x00, 0x8D, 0xD3, 0x8E, 0x85, 0x26, 0x63, 0x1B, 0x26, 0x06, 0x81, 0xA6, 0x03, + 0x83, 0x46, 0x0B, 0x13, 0xA7, 0x07, 0x09, 0x03, 0x46, 0xA1, 0x83, 0xC3, 0x91, 0x88, 0x26, 0xC1, + 0x8E, 0x80, 0xA0, 0x04, 0x1B, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x87, 0x14, 0x94, 0x34, 0xCE, 0xC3, + 0xB8, 0x7C, 0x40, 0x31, 0xE3, 0x79, 0xEB, 0x20, 0x06, 0x34, 0x11, 0xA4, 0xD5, 0x38, 0x0E, 0x65, + 0xF1, 0x00, 0xBD, 0x12, 0xE7, 0xF8, 0x2C, 0x08, 0x40, 0x30, 0x00, 0x66, 0x36, 0x6D, 0x7F, 0x08, + 0x57, 0xA0, 0x20, 0x40, 0x1E, 0x18, 0x54, 0x3E, 0x6B, 0xE0, 0xC1, 0xF0, 0x08, 0x4C, 0x8D, 0x2C, + 0xB5, 0x46, 0x3B, 0xB1, 0xF8, 0x24, 0x10, 0xB4, 0x01, 0xC3, 0x25, 0xE6, 0x37, 0x92, 0x7D, 0xFA, + 0x25, 0x53, 0x00, 0x6B, 0xD1, 0x86, 0x54, 0xBF, 0xD6, 0xE9, 0x6E, 0x06, 0x96, 0xC5, 0xD9, 0x6B, + 0x78, 0x97, 0x48, 0xDE, 0x66, 0x11, 0xC4, 0x6C, 0x3E, 0x56, 0xD1, 0x56, 0x1D, 0x36, 0xF4, 0xEC, + 0xB2, 0x40, 0xA1, 0x86, 0xE9, 0xCB, 0x1F, 0xFA, 0x5E, 0xEA, 0x58, 0x2D, 0x4A, 0x6B, 0xFF, 0xF1, + 0x98, 0xEF, 0x95, 0x11, 0x60, 0xBF, 0x45, 0xAD, 0xC7, 0x81, 0x77, 0xF6, 0x89, 0x05, 0x0F, 0xD2, + 0xDE, 0x50, 0xE2, 0xE2, 0x71, 0x56, 0x68, 0x14, 0x00, 0x20, 0x00, 0x40, 0x06, 0x81, 0x17, 0xF7, + 0xBF, 0xF6, 0x18, 0x58, 0x87, 0x25, 0x04, 0xC4, 0x13, 0x4B, 0x09, 0x63, 0xC9, 0xAA, 0xFD, 0xF0, + 0xEE, 0x78, 0x08, 0x08, 0xE4, 0x4C, 0x18, 0x48, 0x99, 0x32, 0x54, 0x31, 0x11, 0xCF, 0x5F, 0xB0, + 0x8A, 0xF5, 0x39, 0xF1, 0x05, 0x62, 0x79, 0x02, 0xB0, 0x12, 0x8A, 0x80, 0x0B, 0x82, 0x17, 0xB1, + 0x83, 0x42, 0x02, 0x31, 0x69, 0x7D, 0x4C, 0x8F, 0x07, 0x1A, 0x82, 0x19, 0xD5, 0xBA, 0x64, 0xD4, + 0x30, 0x1B, 0x4A, 0x60, 0xE2, 0x29, 0x84, 0x44, 0xA7, 0x56, 0x98, 0x1A, 0xCC, 0x44, 0xD6, 0x08, + 0x43, 0xA6, 0x47, 0x1C, 0xA0, 0xF3, 0x59, 0x11, 0x8B, 0xC6, 0xF8, 0xDB, 0x39, 0x30, 0xB4, 0x7C, + 0xDB, 0x81, 0x7B, 0x40, 0x01, 0x54, 0xC0, 0x64, 0x91, 0xA3, 0x1E, 0x13, 0x04, 0x83, 0xF1, 0x14, + 0x9A, 0x54, 0xAA, 0x41, 0xA4, 0xAD, 0xC5, 0xA4, 0xD6, 0xC8, 0x87, 0xAF, 0x0D, 0x86, 0x00, 0xB5, + 0x8B, 0xEE, 0x90, 0xE0, 0x64, 0x25, 0x2F, 0xC2, 0xC0, 0xAD, 0xC5, 0xAE, 0x94, 0xCB, 0x96, 0x8C, + 0xEF, 0x13, 0x3F, 0xC4, 0x68, 0x5F, 0x50, 0x16, 0xE1, 0x6F, 0xFF, 0xF3, 0x95, 0x6A, 0xF4, 0x6D, + 0x37, 0x96, 0x47, 0xD3, 0x9B, 0xC5, 0x31, 0xE1, 0xD7, 0x04, 0xB0, 0xEF, 0x56, 0x9E, 0x92, 0x16, + 0xD3, 0xD9, 0x88, 0x9A, 0x4D, 0xA2, 0x0A, 0x70, 0x00, 0x00, 0x00, 0x00, 0xA1, 0x05, 0x45, 0x52, + 0x5B, 0xC7, 0xFF, 0xD4, 0xCA, 0xCC, 0x48, 0x30, 0x04, 0x55, 0x07, 0x85, 0x6D, 0x4E, 0xE2, 0x1E, + 0xE6, 0x44, 0x2B, 0x1C, 0xC8, 0x00, 0xE6, 0x6A, 0x7F, 0xF7, 0x25, 0x22, 0x99, 0xFB, 0x71, 0x3B, + 0xC2, 0xD2, 0xA6, 0x96, 0x4E, 0x80, 0x00, 0x03, 0x5D, 0x81, 0x8C, 0x06, 0x17, 0x35, 0xB8, 0x2C, + 0xC9, 0x00, 0x73, 0x02, 0x10, 0x01, 0x29, 0x73, 0xF1, 0xBB, 0x8D, 0x3A, 0x09, 0x30, 0x9B, 0xE0, + 0x02, 0x46, 0x12, 0xDC, 0x82, 0x46, 0xE5, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x74, 0x84, 0x34, + 0xCE, 0x2B, 0x9A, 0x7B, 0x64, 0x2F, 0x46, 0x59, 0xC4, 0x14, 0xC2, 0x88, 0x52, 0x24, 0xD3, 0x38, + 0x0E, 0x61, 0xF2, 0xD0, 0xAE, 0x19, 0xA6, 0x94, 0x72, 0x8E, 0xA3, 0x01, 0x73, 0xA0, 0xD6, 0x0F, + 0x42, 0xC4, 0x39, 0x98, 0x42, 0x47, 0xC5, 0xA3, 0xCC, 0xA8, 0x01, 0x32, 0x44, 0xB2, 0xBD, 0xC8, + 0x11, 0x35, 0x27, 0xEC, 0x20, 0x3C, 0x90, 0x50, 0x39, 0xAC, 0x21, 0xC3, 0x11, 0x8B, 0x69, 0x30, + 0x22, 0x14, 0x85, 0x59, 0x22, 0x3A, 0xF6, 0x4E, 0xA0, 0x40, 0x06, 0xD6, 0xB2, 0x86, 0x37, 0xD3, + 0x31, 0xF0, 0xC0, 0xC5, 0xFA, 0x50, 0x02, 0xE2, 0x0D, 0x3D, 0xA4, 0xA1, 0x41, 0x84, 0x75, 0xBE, + 0x97, 0xD0, 0x97, 0x0D, 0xDB, 0x09, 0xE5, 0x16, 0x1E, 0xB2, 0xEB, 0x3B, 0x7D, 0xFF, 0xFE, 0x9E, + 0x55, 0x02, 0xA4, 0xFB, 0x73, 0x8A, 0x23, 0x85, 0xB9, 0x2C, 0xFC, 0x7C, 0xC1, 0xC1, 0x9C, 0xD9, + 0x58, 0xA4, 0xC1, 0x56, 0x8F, 0x44, 0x13, 0xD2, 0xC3, 0x72, 0x02, 0x00, 0x60, 0x00, 0x98, 0x48, + 0x7C, 0x68, 0x63, 0x7F, 0xEB, 0xD0, 0x8F, 0xE2, 0xF1, 0x56, 0x66, 0xF4, 0xE2, 0x3B, 0xB2, 0xD0, + 0x2C, 0xC7, 0xAC, 0xCE, 0x4D, 0xD1, 0x2E, 0x35, 0xDD, 0xBD, 0x9F, 0xA1, 0x5C, 0x8F, 0xD3, 0xFA, + 0xEF, 0x95, 0x9D, 0x46, 0xD0, 0xBB, 0xB8, 0xEE, 0x56, 0x5E, 0x87, 0xA4, 0x80, 0x93, 0x5F, 0x33, + 0x54, 0x2C, 0xC5, 0x06, 0x83, 0x07, 0x17, 0x4D, 0xF0, 0x36, 0x33, 0xF2, 0x9C, 0xCF, 0x0C, 0x93, + 0x37, 0xB3, 0xCC, 0x98, 0x47, 0x2A, 0x81, 0x8C, 0x10, 0x8A, 0x3D, 0x63, 0x74, 0xD0, 0x42, 0x93, + 0x00, 0x87, 0x0C, 0xAC, 0xBE, 0x30, 0x68, 0x15, 0x67, 0x97, 0x30, 0xC9, 0x82, 0x71, 0xA0, 0x23, + 0x77, 0x30, 0x48, 0xB4, 0xB6, 0x93, 0xC8, 0xDA, 0x79, 0x92, 0x7C, 0x38, 0x0A, 0x50, 0x1D, 0x97, + 0xFD, 0x1D, 0x0B, 0xE8, 0x7A, 0x29, 0x7F, 0x5C, 0x15, 0xF4, 0xBA, 0x5E, 0x4A, 0xEA, 0xAD, 0x7B, + 0x4F, 0x4B, 0x44, 0x6B, 0x62, 0x24, 0x9E, 0x4B, 0x58, 0x02, 0x11, 0x23, 0x97, 0x4A, 0x05, 0xF7, + 0x94, 0xC9, 0xCE, 0xDA, 0xC5, 0x11, 0xD4, 0xAC, 0x0A, 0xDD, 0xFF, 0xE5, 0x75, 0xFF, 0xFF, 0x7D, + 0xAD, 0xA1, 0x9D, 0x48, 0xAC, 0x2E, 0xAB, 0xB5, 0x49, 0x37, 0x3F, 0x8E, 0xA6, 0x6A, 0xAE, 0x9C, + 0xDF, 0x21, 0x26, 0x42, 0x84, 0xE8, 0x7C, 0xB6, 0x4F, 0x28, 0x22, 0x98, 0xD3, 0x48, 0xB7, 0xFF, + 0xE8, 0x36, 0x7E, 0x20, 0x30, 0xAE, 0x16, 0x20, 0x18, 0xD1, 0x8A, 0xE2, 0x62, 0x71, 0xDC, 0x82, + 0x80, 0xA1, 0x61, 0xAF, 0x3F, 0x9F, 0xA1, 0x1A, 0x9E, 0x8F, 0xFF, 0x38, 0x48, 0x4E, 0xEC, 0xE5, + 0x7E, 0x15, 0x07, 0x90, 0x82, 0x15, 0x80, 0x00, 0x00, 0x20, 0x77, 0x92, 0xA5, 0x32, 0x0D, 0xC6, + 0xC0, 0x30, 0x88, 0x81, 0x1D, 0x8C, 0xD2, 0xA3, 0x37, 0x81, 0xA4, 0x80, 0x7E, 0x6E, 0x84, 0xF1, + 0xC4, 0x81, 0x66, 0x0D, 0x25, 0x98, 0x9C, 0xFC, 0x63, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x8D, 0x14, + 0x7C, 0x34, 0xCE, 0x43, 0x99, 0x7B, 0xD0, 0x30, 0x06, 0x89, 0xB9, 0x15, 0x22, 0x96, 0x11, 0xD0, + 0xCF, 0x38, 0x0E, 0x65, 0xF1, 0x18, 0xBA, 0x17, 0xE5, 0x40, 0x60, 0x34, 0x71, 0xEB, 0x71, 0x8C, + 0x41, 0x83, 0xC0, 0xB3, 0x2A, 0xA9, 0x43, 0xDD, 0xC1, 0x93, 0x11, 0x00, 0x58, 0xF9, 0x93, 0x97, + 0xA1, 0xAB, 0x80, 0xE1, 0x4E, 0x19, 0x18, 0xA2, 0x20, 0x66, 0x59, 0x4A, 0x61, 0xB4, 0xE5, 0xD8, + 0xA1, 0xA5, 0x84, 0x16, 0xF2, 0x84, 0xBA, 0x41, 0x70, 0xD1, 0x10, 0x44, 0x1C, 0xBE, 0x32, 0x9D, + 0xEF, 0x3D, 0x05, 0x08, 0x88, 0x87, 0x4D, 0xCA, 0x05, 0x0E, 0x06, 0xAD, 0xE8, 0x69, 0xEF, 0xB2, + 0x57, 0x79, 0xE7, 0xE3, 0xFB, 0x32, 0xCE, 0xAB, 0xD4, 0x96, 0xFF, 0x1E, 0xBA, 0xFF, 0xFF, 0x7B, + 0xFB, 0xA2, 0x0B, 0x80, 0xF4, 0x0A, 0x79, 0x94, 0x86, 0x21, 0xCB, 0x27, 0xF2, 0x6A, 0xB2, 0xA0, + 0x16, 0x13, 0xCF, 0xD1, 0x2A, 0xA3, 0x35, 0xD2, 0x86, 0x64, 0x00, 0x03, 0x00, 0x20, 0x02, 0x2C, + 0x19, 0xFF, 0xFF, 0xFA, 0x73, 0x82, 0xE6, 0xD6, 0x55, 0x12, 0x8D, 0xE7, 0x43, 0x66, 0x6B, 0x7D, + 0xFF, 0x84, 0xE4, 0x8D, 0x28, 0x7F, 0xF5, 0x79, 0x0B, 0x55, 0xA2, 0xD9, 0xBF, 0xFD, 0x45, 0x45, + 0x4C, 0x2A, 0x02, 0xE8, 0x2B, 0x3B, 0x68, 0x47, 0x30, 0x96, 0x70, 0x50, 0x07, 0x0A, 0x05, 0xC0, + 0x56, 0xD3, 0x10, 0x07, 0x0C, 0x62, 0x07, 0x31, 0x7C, 0x2C, 0xC4, 0x03, 0x31, 0xA0, 0x51, 0x84, + 0x42, 0xC6, 0xAE, 0x03, 0x05, 0x01, 0x66, 0x1A, 0x03, 0x19, 0xB5, 0xFE, 0x62, 0x30, 0x81, 0x84, + 0x40, 0x66, 0x36, 0xBA, 0x93, 0x8C, 0x80, 0x84, 0x11, 0x61, 0x49, 0x93, 0x81, 0x68, 0xDA, 0xE3, + 0x19, 0xDE, 0xB9, 0xEE, 0xF1, 0x08, 0xA2, 0x42, 0xB3, 0x6B, 0x05, 0xD9, 0x7A, 0xD3, 0xD0, 0x01, + 0x29, 0x77, 0xC4, 0x66, 0x17, 0xE8, 0x98, 0x84, 0xC8, 0x86, 0x84, 0xA0, 0x68, 0x74, 0xEE, 0x89, + 0x40, 0x6B, 0x9E, 0x36, 0x9C, 0x09, 0x9A, 0xD8, 0x0F, 0x04, 0x01, 0xC9, 0x01, 0x45, 0x65, 0x96, + 0xA6, 0xAE, 0xBB, 0x39, 0x54, 0xB8, 0x83, 0x56, 0x68, 0x4D, 0x2B, 0x7B, 0xFF, 0xFF, 0xFF, 0xFF, + 0x2C, 0x6B, 0x0D, 0x8D, 0xCB, 0xE4, 0x91, 0x34, 0x84, 0xB6, 0xB0, 0xE1, 0x18, 0x6D, 0x44, 0x78, + 0xE2, 0xA9, 0x5E, 0x7F, 0xE1, 0x9C, 0xD1, 0x16, 0x72, 0x23, 0x7F, 0x69, 0x24, 0x99, 0x59, 0x22, + 0x58, 0x4D, 0x35, 0x0F, 0xA9, 0xDE, 0xA4, 0x9F, 0xA8, 0xE2, 0x65, 0x33, 0xCA, 0x4B, 0xF2, 0x21, + 0xA9, 0xB1, 0xA2, 0x09, 0x99, 0x4D, 0x3F, 0xFD, 0x65, 0xF3, 0x53, 0xAA, 0x5B, 0x58, 0xBA, 0xCA, + 0x76, 0x62, 0x71, 0x7D, 0xB0, 0x52, 0x55, 0xA0, 0x00, 0x07, 0x65, 0xE3, 0x01, 0xA3, 0x79, 0xAA, + 0xCB, 0x3E, 0x54, 0x04, 0x19, 0xA0, 0x00, 0x61, 0x90, 0x61, 0x82, 0x10, 0x86, 0x95, 0x85, 0x19, + 0x8C, 0xA6, 0x0E, 0x0E, 0x1A, 0x24, 0x74, 0x6A, 0x0D, 0x11, 0x59, 0xFF, 0xFB, 0x90, 0x64, 0x12, + 0x07, 0xF4, 0xA1, 0x33, 0xCD, 0xAB, 0x9A, 0x7B, 0xD0, 0x2D, 0x86, 0x99, 0x00, 0x0C, 0x0A, 0x1E, + 0x12, 0x48, 0xD1, 0x38, 0x0E, 0x65, 0x92, 0xC0, 0xBE, 0x94, 0xE2, 0x41, 0x80, 0x34, 0xB8, 0x0D, + 0x62, 0x18, 0xCA, 0x02, 0x7C, 0xD2, 0x69, 0x93, 0x86, 0x24, 0xD0, 0xC6, 0xED, 0x12, 0x5E, 0x83, + 0xC3, 0xB2, 0x8C, 0x1A, 0xA4, 0xF9, 0x1C, 0x12, 0x5A, 0xF4, 0xAF, 0x72, 0x41, 0xC4, 0x92, 0x11, + 0x84, 0x17, 0x7C, 0x3D, 0x3A, 0x2B, 0x22, 0x68, 0xA0, 0x38, 0xCC, 0x50, 0x74, 0x10, 0x08, 0x86, + 0x31, 0xD0, 0xE5, 0x69, 0x55, 0x19, 0x86, 0x95, 0x45, 0x32, 0x8C, 0x98, 0xC0, 0xCA, 0x88, 0xAA, + 0x90, 0x35, 0xE1, 0xB0, 0x62, 0xC7, 0x21, 0xEC, 0x3F, 0x54, 0xF0, 0x59, 0x36, 0xAA, 0x46, 0x7F, + 0xE1, 0xC4, 0xF0, 0x22, 0x7F, 0xE0, 0x64, 0xC7, 0x3F, 0xD8, 0x48, 0x30, 0x9A, 0x0F, 0x01, 0xB0, + 0x8F, 0x59, 0x90, 0xB9, 0x9D, 0x6E, 0x2B, 0x85, 0x65, 0x6C, 0x96, 0x81, 0x09, 0x43, 0x94, 0x51, + 0x57, 0x41, 0xE9, 0x29, 0xCB, 0x21, 0x1E, 0x90, 0x09, 0xCA, 0x6F, 0xF9, 0x11, 0xEA, 0x6F, 0xF9, + 0x30, 0xC4, 0x29, 0x03, 0xF0, 0x69, 0x0B, 0x80, 0x0B, 0x02, 0xE8, 0x16, 0xFA, 0xFF, 0x80, 0xC8, + 0xE2, 0xCD, 0x36, 0x8F, 0x39, 0x4D, 0x69, 0xD4, 0x79, 0xC7, 0x15, 0x1E, 0xB4, 0x45, 0x9E, 0x01, + 0x03, 0x46, 0x9A, 0x9B, 0x03, 0x80, 0xA3, 0x00, 0xB3, 0x00, 0x8F, 0x81, 0x27, 0xD3, 0x16, 0x86, + 0x0D, 0x1C, 0x50, 0x35, 0x4B, 0x30, 0xC6, 0x01, 0x73, 0x06, 0x1D, 0x4C, 0x9E, 0xCA, 0x39, 0xC1, + 0x48, 0x54, 0x46, 0x60, 0x33, 0x69, 0xA2, 0x6D, 0x80, 0x28, 0x51, 0x84, 0x00, 0xA5, 0x02, 0x13, + 0x26, 0x93, 0x43, 0x06, 0xC1, 0x50, 0x81, 0x92, 0x45, 0xE1, 0x02, 0x37, 0xCA, 0x01, 0x22, 0x29, + 0x2E, 0xD0, 0xA0, 0x33, 0x42, 0x82, 0xD4, 0x58, 0xC2, 0xC1, 0xBA, 0x21, 0x19, 0x79, 0x1F, 0xF8, + 0xA3, 0x2A, 0x05, 0x03, 0x71, 0xA4, 0x25, 0xC2, 0x12, 0x73, 0x83, 0x05, 0x99, 0x33, 0x49, 0x0A, + 0x06, 0x5D, 0x13, 0x38, 0xE7, 0xFE, 0x37, 0xF9, 0x32, 0x4F, 0x2D, 0x8F, 0xC3, 0x4B, 0x6D, 0xCC, + 0xA3, 0xE9, 0x94, 0x95, 0x98, 0x1B, 0x99, 0x9F, 0x3A, 0x58, 0xA9, 0x19, 0xE8, 0x2C, 0x72, 0x02, + 0x0E, 0x14, 0xA9, 0x4A, 0x69, 0xA8, 0x43, 0xBE, 0x68, 0xF4, 0x6E, 0x0D, 0x81, 0xAC, 0x7E, 0xF0, + 0x82, 0x52, 0x1C, 0x7C, 0xB1, 0xFE, 0x60, 0xB1, 0xD8, 0x32, 0x44, 0xAD, 0xFF, 0xD7, 0xFF, 0x4C, + 0xF0, 0x8D, 0x00, 0x91, 0x18, 0x51, 0x08, 0x1C, 0x91, 0xB0, 0x96, 0x52, 0x78, 0x9A, 0x00, 0xEB, + 0x2D, 0x6E, 0xB2, 0x70, 0x3A, 0x88, 0xC9, 0x7F, 0xFF, 0xFF, 0xF4, 0x7F, 0xFF, 0xFE, 0x85, 0x80, + 0x00, 0x00, 0x00, 0x04, 0x13, 0x88, 0xDC, 0x01, 0x15, 0x99, 0x4E, 0x36, 0x2C, 0x0F, 0x6C, 0xA0, + 0xD1, 0x49, 0xD7, 0xD2, 0x26, 0x33, 0x06, 0x01, 0x02, 0xE6, 0x2B, 0x8A, 0xFF, 0xFB, 0x92, 0x64, + 0x0E, 0x85, 0x34, 0x4D, 0x34, 0x4F, 0x5B, 0x99, 0x5C, 0x40, 0x31, 0x64, 0x98, 0xD0, 0x34, 0xD1, + 0x74, 0x11, 0x44, 0xD3, 0x3B, 0x0E, 0x65, 0x32, 0xC0, 0xC4, 0x9A, 0x65, 0x90, 0xD3, 0x1E, 0x08, + 0x80, 0x00, 0x63, 0xC5, 0x03, 0x15, 0x87, 0x0C, 0x93, 0x03, 0x31, 0xA8, 0x20, 0xC2, 0xC0, 0xF3, + 0x13, 0x6E, 0xCD, 0x0A, 0x0F, 0x30, 0x30, 0x11, 0xAF, 0x98, 0x08, 0xB0, 0x64, 0x04, 0x83, 0x80, + 0x88, 0x4C, 0x67, 0x9C, 0xD6, 0x32, 0x21, 0x31, 0xB6, 0x63, 0xA2, 0x30, 0x0E, 0x11, 0x5F, 0xD2, + 0xD5, 0x1B, 0xEE, 0x22, 0x91, 0x73, 0xA2, 0x1B, 0x83, 0x1D, 0xAD, 0x2B, 0x35, 0x02, 0xBE, 0xB4, + 0xD8, 0xA9, 0x53, 0x08, 0xB2, 0x69, 0x6A, 0xB2, 0x1D, 0xEB, 0x47, 0xBE, 0x4D, 0x40, 0xE9, 0x91, + 0xA1, 0x41, 0x1F, 0x94, 0x2F, 0xD4, 0xF8, 0x77, 0xF3, 0xA9, 0x16, 0xBC, 0x18, 0x92, 0xC8, 0x30, + 0x21, 0x4D, 0x13, 0x46, 0x28, 0x95, 0xAA, 0xB1, 0x98, 0xFE, 0x1F, 0x0E, 0x5C, 0x0F, 0x10, 0x22, + 0x9F, 0x52, 0x29, 0x12, 0x41, 0x78, 0x35, 0x7F, 0xF3, 0xC7, 0x99, 0x24, 0xC9, 0xEC, 0x5E, 0xFB, + 0xD6, 0xF7, 0x04, 0x34, 0x40, 0xE6, 0x8B, 0xDB, 0xF9, 0xD3, 0x74, 0x13, 0x7E, 0xA0, 0x97, 0x1B, + 0x05, 0xE9, 0xC4, 0x10, 0x5B, 0x4E, 0x0B, 0x40, 0xA1, 0x9F, 0x96, 0xFB, 0xBE, 0x1F, 0xC0, 0x00, + 0x35, 0xE4, 0x30, 0x2D, 0x21, 0x9F, 0x89, 0x01, 0x8D, 0xB3, 0x0F, 0x00, 0x0C, 0x20, 0x49, 0x31, + 0xAE, 0x88, 0xC8, 0x84, 0x43, 0x1B, 0x89, 0xCD, 0x14, 0x8F, 0x34, 0xE2, 0x30, 0x60, 0x80, 0x64, + 0xD0, 0xC1, 0x02, 0xE0, 0xDB, 0x63, 0xD2, 0xE0, 0x18, 0xD1, 0x66, 0x70, 0x57, 0x90, 0x39, 0xD8, + 0xED, 0x95, 0x46, 0x86, 0x59, 0x3D, 0x87, 0x0B, 0xD0, 0x46, 0x60, 0xE0, 0x79, 0xF4, 0x21, 0x76, + 0x8A, 0x0B, 0x10, 0x08, 0xFA, 0xBB, 0x85, 0x83, 0x40, 0x81, 0x31, 0x26, 0x48, 0x5F, 0xD3, 0x28, + 0x62, 0x61, 0x3B, 0xC9, 0x4D, 0xE8, 0x94, 0x6A, 0x97, 0x0A, 0x68, 0xEA, 0xEC, 0x30, 0x07, 0x0B, + 0x06, 0x2C, 0x5B, 0x31, 0x77, 0x18, 0xBF, 0xC4, 0x60, 0xA9, 0x20, 0x8C, 0x35, 0x49, 0x70, 0x7D, + 0xFF, 0xA0, 0x87, 0xFF, 0xFF, 0xFF, 0x96, 0xF9, 0x12, 0x34, 0x50, 0x4C, 0x06, 0xC1, 0x17, 0x18, + 0xCF, 0xB8, 0xA0, 0x22, 0xB1, 0x10, 0x81, 0xB9, 0x80, 0x18, 0x0E, 0x00, 0x1C, 0xC8, 0xE7, 0x52, + 0xDC, 0x0C, 0x01, 0x6A, 0xCF, 0xAF, 0xC2, 0xD8, 0x58, 0xE4, 0x02, 0x31, 0x89, 0xAF, 0x88, 0x07, + 0x8D, 0xD4, 0x54, 0x01, 0xC5, 0xA9, 0x3F, 0xFC, 0x20, 0x3C, 0xFE, 0xA4, 0xCF, 0xD8, 0x6E, 0x7C, + 0x71, 0xA8, 0xE5, 0x7F, 0xFF, 0xE8, 0xBF, 0xFC, 0x71, 0x95, 0xC0, 0x00, 0x00, 0x00, 0x10, 0x80, + 0x90, 0x59, 0x81, 0x60, 0xF1, 0x8A, 0x8A, 0x51, 0x80, 0x01, 0x91, 0x10, 0xB2, 0x23, 0x17, 0xCC, + 0x83, 0x87, 0x4C, 0x0D, 0x03, 0x0C, 0x74, 0x11, 0xCC, 0x51, 0x06, 0x4C, 0x9E, 0x3E, 0xFF, 0xFB, + 0x92, 0x64, 0x12, 0x07, 0x24, 0xA2, 0x34, 0x4E, 0x43, 0xB8, 0x7C, 0xB0, 0x31, 0x46, 0x99, 0xCB, + 0x29, 0x25, 0xB0, 0x10, 0xF4, 0xD3, 0x3A, 0xAE, 0x65, 0xF2, 0xD0, 0xC9, 0x16, 0xA7, 0x50, 0x90, + 0x9C, 0x98, 0x4C, 0x27, 0x0F, 0x8C, 0x0D, 0x0D, 0xCC, 0x41, 0x0E, 0x0D, 0xD5, 0x07, 0x40, 0x44, + 0x98, 0x24, 0x2E, 0x2A, 0x90, 0x26, 0x86, 0x05, 0x0B, 0x50, 0x20, 0x1A, 0x0A, 0x85, 0x06, 0x37, + 0x81, 0xAC, 0xB5, 0x13, 0x0C, 0x31, 0x4E, 0xA5, 0xAA, 0x30, 0x22, 0x37, 0x22, 0x7B, 0x80, 0xC8, + 0x06, 0x7F, 0x00, 0x8E, 0x05, 0x8C, 0x86, 0x16, 0x7F, 0x29, 0xA4, 0xC8, 0x7C, 0xAD, 0xEF, 0x99, + 0x50, 0xA4, 0x02, 0x14, 0xAA, 0xA1, 0x80, 0x20, 0x7A, 0x29, 0x7C, 0xF1, 0x77, 0xD8, 0x52, 0x6D, + 0xEB, 0xCA, 0x12, 0x8E, 0x8C, 0x67, 0xBE, 0xFE, 0x4D, 0xE6, 0xCA, 0x53, 0xFF, 0xFF, 0xFF, 0xDE, + 0x8B, 0xA5, 0x71, 0x7A, 0x80, 0x45, 0x21, 0x44, 0x81, 0x53, 0xBF, 0x4C, 0xDD, 0x4C, 0x7E, 0xB1, + 0x27, 0x99, 0x00, 0x00, 0x0E, 0xC0, 0x00, 0x45, 0x16, 0xA7, 0xBD, 0xC3, 0x22, 0xDB, 0xD3, 0x43, + 0x08, 0xDA, 0x50, 0x43, 0xD0, 0x45, 0xB9, 0xE3, 0x03, 0x7E, 0x5C, 0x4F, 0x9F, 0x91, 0x93, 0xEF, + 0x9C, 0xF1, 0x20, 0x80, 0xFE, 0xA2, 0x15, 0xC8, 0xB3, 0x71, 0x2B, 0x7F, 0xFD, 0x4E, 0x87, 0x74, + 0x6F, 0xF5, 0x17, 0x68, 0x19, 0x34, 0x02, 0x5F, 0xC3, 0x32, 0xC5, 0x0D, 0x34, 0x28, 0x08, 0x11, + 0x18, 0x1C, 0x1C, 0x74, 0x88, 0xA1, 0xB7, 0x42, 0x26, 0x3C, 0x46, 0x18, 0x80, 0x2C, 0x0D, 0x9B, + 0x06, 0x21, 0x0C, 0x2A, 0x33, 0x32, 0x68, 0x84, 0xE3, 0x8C, 0xC6, 0x74, 0x01, 0x1B, 0x27, 0xF1, + 0x90, 0x8E, 0xF1, 0xB5, 0x04, 0x21, 0x04, 0x9A, 0xDC, 0x0E, 0x8B, 0x64, 0x80, 0x31, 0x58, 0x4E, + 0x50, 0x60, 0xAA, 0x70, 0xA5, 0x62, 0x49, 0x41, 0xF2, 0xA5, 0x30, 0x28, 0x49, 0xF5, 0x19, 0x2D, + 0x30, 0x35, 0x7A, 0x9C, 0x12, 0x1C, 0x57, 0x2D, 0xE5, 0xFA, 0x71, 0x03, 0xB7, 0x45, 0x39, 0x11, + 0x76, 0x87, 0x82, 0x55, 0xFF, 0x88, 0x10, 0x4B, 0x6A, 0xAD, 0xB1, 0xBD, 0x85, 0x6F, 0x57, 0xB5, + 0x1F, 0xC6, 0x38, 0xE2, 0x7F, 0xFF, 0xFF, 0xDD, 0x7A, 0xB1, 0x32, 0x73, 0x3F, 0x2E, 0xED, 0xE2, + 0x3E, 0xA0, 0x8F, 0x78, 0xCD, 0x56, 0xCF, 0x45, 0x98, 0xC9, 0x5D, 0x20, 0x10, 0x5D, 0x00, 0x16, + 0x41, 0x2E, 0x98, 0x92, 0x4C, 0x4E, 0xBA, 0x63, 0x71, 0x6B, 0x47, 0x86, 0xCE, 0x84, 0xE5, 0x42, + 0xC4, 0x32, 0xB8, 0xD4, 0x7A, 0x8C, 0x44, 0x6D, 0xF5, 0x1B, 0x0E, 0x30, 0x8E, 0x5F, 0xCD, 0x43, + 0x5D, 0x52, 0xDF, 0xBF, 0xFE, 0x38, 0x55, 0xD6, 0x54, 0x48, 0x4A, 0x4E, 0xA3, 0x2A, 0xC0, 0x00, + 0x00, 0x00, 0x62, 0x20, 0x10, 0x10, 0x70, 0x18, 0x11, 0x83, 0x20, 0xA7, 0xB4, 0xB6, 0xC6, 0x0A, + 0x08, 0xC1, 0x59, 0x90, 0xC7, 0x00, 0x18, 0xC4, 0x70, 0xCC, 0xC0, 0xA0, 0x04, 0xC3, 0xF4, 0x04, + 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x34, 0x87, 0x34, 0xCE, 0xC3, 0xBA, 0x7B, 0xD0, 0x2F, 0x66, + 0x89, 0xB4, 0x19, 0x05, 0x0E, 0x11, 0xA8, 0xD1, 0x3A, 0x0E, 0x6F, 0x09, 0x40, 0xBD, 0x19, 0x66, + 0x50, 0xA3, 0x2A, 0x89, 0xC2, 0x60, 0x90, 0xC0, 0xD1, 0x0C, 0x58, 0x01, 0x34, 0x14, 0x9D, 0x30, + 0x50, 0x10, 0x10, 0x81, 0x46, 0x69, 0x59, 0xF3, 0xE8, 0xDF, 0x16, 0x00, 0x00, 0x4A, 0x9D, 0x4A, + 0xCD, 0x95, 0xD8, 0x6B, 0x81, 0xDC, 0xA9, 0x9C, 0x50, 0xA9, 0x30, 0x70, 0x0B, 0x79, 0x29, 0x41, + 0x40, 0xA8, 0x9A, 0xF5, 0x05, 0x1C, 0x7B, 0x6B, 0xBC, 0x85, 0xF9, 0x6C, 0xF8, 0x6A, 0xED, 0xDA, + 0xEC, 0x80, 0x18, 0x81, 0x5B, 0xA3, 0xE9, 0x10, 0x0E, 0x49, 0x4F, 0xAC, 0x37, 0x40, 0x3D, 0xD5, + 0x92, 0x59, 0x7F, 0x17, 0x91, 0xAA, 0x2D, 0x61, 0xB5, 0xB8, 0xFF, 0xFF, 0xFF, 0xCA, 0xA6, 0x31, + 0xEF, 0x2A, 0x68, 0x2E, 0xD1, 0x30, 0x8D, 0x00, 0x78, 0x67, 0x19, 0x2B, 0x33, 0x05, 0x90, 0x87, + 0x9A, 0x0F, 0x74, 0x88, 0x00, 0x76, 0x28, 0x70, 0x68, 0xE4, 0x54, 0xCF, 0x21, 0x76, 0x5F, 0x9F, + 0x01, 0xB5, 0xDE, 0xB1, 0x68, 0x4C, 0x14, 0x13, 0x1A, 0x75, 0x01, 0x4B, 0x72, 0x87, 0xBE, 0x8A, + 0xA0, 0x59, 0xCD, 0xFC, 0x9C, 0xBF, 0x41, 0xBF, 0xFA, 0x19, 0xE2, 0x26, 0x1A, 0x93, 0x6A, 0xD9, + 0xD8, 0x49, 0xD1, 0x64, 0xBF, 0x42, 0x82, 0xD3, 0x0A, 0xD0, 0x4D, 0x0C, 0x17, 0x0E, 0x07, 0x18, + 0xF4, 0x56, 0x6F, 0x5A, 0x99, 0xC2, 0x00, 0x46, 0x54, 0x3C, 0x18, 0x39, 0xF1, 0xDD, 0x04, 0x98, + 0x50, 0xB0, 0xC1, 0x39, 0x87, 0x09, 0x1F, 0xF4, 0x12, 0xFD, 0x53, 0x23, 0x00, 0x04, 0x3A, 0xE2, + 0xF0, 0x81, 0x96, 0xA6, 0x61, 0x86, 0x06, 0xD4, 0x82, 0xDC, 0x1E, 0x70, 0xA1, 0x20, 0x38, 0x1A, + 0x2A, 0x82, 0xE2, 0x30, 0xD2, 0x32, 0xDB, 0x78, 0x04, 0x5C, 0x6B, 0xDC, 0x20, 0x91, 0x7E, 0x14, + 0xF4, 0xC2, 0x70, 0x08, 0x49, 0x2A, 0xDE, 0x74, 0xFC, 0xA8, 0x48, 0x23, 0x43, 0xD5, 0xEC, 0xC3, + 0xF4, 0x03, 0x3E, 0xB7, 0xFF, 0x13, 0xFA, 0xCF, 0xCD, 0xCE, 0x41, 0xB7, 0xBF, 0x6E, 0xF4, 0x9B, + 0x75, 0x6D, 0x59, 0xF9, 0xCF, 0xEF, 0xF3, 0x96, 0xF1, 0x7D, 0xE3, 0x1F, 0x61, 0x87, 0xB4, 0xAA, + 0x17, 0xA9, 0x76, 0x30, 0xD9, 0xE9, 0x42, 0xC3, 0xBD, 0xBD, 0x92, 0x27, 0xC4, 0x3F, 0x43, 0xA0, + 0x00, 0x02, 0x31, 0x05, 0x89, 0x71, 0x78, 0x68, 0x64, 0xE0, 0x25, 0xB7, 0x67, 0x43, 0xBE, 0xBC, + 0x62, 0x21, 0x8C, 0x40, 0xB8, 0x42, 0xC4, 0x29, 0x12, 0xE4, 0xC5, 0x75, 0x1F, 0xBE, 0x40, 0x0A, + 0x0C, 0x13, 0x5B, 0xFF, 0xA3, 0xA3, 0x66, 0x37, 0x6D, 0xFF, 0xD7, 0xFE, 0xA5, 0x5A, 0x9E, 0x80, + 0x00, 0x04, 0x32, 0xC2, 0x84, 0x01, 0x21, 0x80, 0x4C, 0x99, 0x8A, 0x20, 0xDA, 0xA5, 0x30, 0x9C, + 0x36, 0x36, 0xA2, 0x1F, 0x32, 0x30, 0x33, 0x78, 0x7B, 0x34, 0xD3, 0x73, 0xB3, 0x3E, 0x33, 0x54, + 0xA3, 0x06, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x87, 0x34, 0xAC, 0x34, 0x4E, 0x2B, 0xBB, 0xC9, 0xD4, + 0x2F, 0x26, 0x99, 0xB9, 0x29, 0x22, 0xA2, 0x92, 0x18, 0xD1, 0x38, 0x0E, 0xE9, 0xEB, 0xC0, 0xBA, + 0x8E, 0xE5, 0x60, 0xD0, 0x1D, 0x50, 0x5F, 0x36, 0x61, 0x43, 0xD9, 0x51, 0x03, 0x06, 0x20, 0x9C, + 0x2A, 0xA4, 0x6E, 0xE6, 0xA0, 0x60, 0x66, 0x72, 0x2A, 0xB4, 0x67, 0x20, 0xAA, 0x49, 0xF4, 0x1D, + 0xD9, 0x31, 0x5B, 0x8A, 0xED, 0x15, 0x25, 0x3C, 0x2B, 0x42, 0x0E, 0x32, 0x69, 0x22, 0xA2, 0xAC, + 0x00, 0x9D, 0x7C, 0x9B, 0x94, 0x25, 0x40, 0x5F, 0x2E, 0x33, 0x37, 0xBE, 0x9B, 0x01, 0xD3, 0x04, + 0x97, 0x79, 0xAB, 0xA3, 0x78, 0x41, 0xD6, 0xE4, 0xAD, 0x0F, 0x2A, 0x2C, 0x9B, 0x8D, 0x3D, 0x4C, + 0x5E, 0x49, 0xDF, 0xBA, 0xEE, 0xD9, 0xB1, 0x04, 0xDA, 0xCB, 0xDE, 0xBB, 0x7F, 0xAB, 0xBE, 0xFA, + 0x4F, 0xAF, 0x99, 0x2C, 0x03, 0x2A, 0x48, 0x55, 0xCB, 0x3C, 0xA3, 0xCF, 0x4B, 0x76, 0xC9, 0xCB, + 0xC6, 0x93, 0xAD, 0x89, 0xFA, 0xAA, 0xB3, 0x1D, 0xB0, 0x00, 0xC3, 0x00, 0x0C, 0x02, 0x85, 0xF2, + 0x00, 0xD7, 0x2A, 0x14, 0x88, 0xBF, 0xFD, 0xBC, 0xA8, 0xC0, 0xBE, 0x26, 0x0C, 0x37, 0xCE, 0x03, + 0xB6, 0x80, 0x9D, 0x0C, 0x7A, 0x95, 0xF7, 0x01, 0x41, 0xCF, 0x06, 0xFF, 0x45, 0xF6, 0xA9, 0x8F, + 0xA6, 0xAD, 0xFF, 0xFE, 0xB5, 0xB9, 0x44, 0xBB, 0xF4, 0x91, 0x05, 0xDE, 0x32, 0x40, 0xCB, 0x33, + 0x6C, 0x09, 0x31, 0x60, 0x05, 0x30, 0x58, 0x53, 0x33, 0xCE, 0x30, 0x31, 0x5C, 0x2A, 0x30, 0x6C, + 0x46, 0x30, 0xB8, 0x10, 0x33, 0x40, 0x2D, 0x32, 0xB7, 0x4C, 0x74, 0x51, 0x82, 0x06, 0xE5, 0x20, + 0x70, 0x95, 0x88, 0x04, 0xA8, 0x7E, 0xC8, 0x34, 0x3A, 0x40, 0x0C, 0xC0, 0x56, 0xE7, 0x7D, 0xA8, + 0x05, 0x43, 0x2F, 0x76, 0x08, 0xA1, 0xE4, 0x03, 0xD5, 0x1D, 0xA4, 0x1F, 0x28, 0x50, 0xDC, 0x5A, + 0x18, 0x80, 0x73, 0x91, 0x4F, 0x30, 0x8C, 0xCB, 0x8B, 0x1B, 0x0C, 0x6E, 0x35, 0xBA, 0x65, 0xE0, + 0xE0, 0x48, 0x90, 0xE0, 0x60, 0x0C, 0xBC, 0x2F, 0x14, 0x82, 0xD1, 0x3D, 0xA4, 0x66, 0x5D, 0xBA, + 0x75, 0x05, 0x96, 0xDE, 0x37, 0x52, 0x1F, 0xAA, 0x87, 0x98, 0x4A, 0xAD, 0x7B, 0xAD, 0x51, 0xA5, + 0x3E, 0x4E, 0x95, 0xC9, 0x92, 0x14, 0x82, 0x44, 0x16, 0x30, 0x6D, 0x1F, 0x82, 0x51, 0x60, 0x5B, + 0x5C, 0x31, 0xB5, 0xC2, 0x1E, 0x86, 0xAF, 0x9D, 0x00, 0x08, 0x04, 0x4A, 0x8B, 0x71, 0x06, 0x14, + 0x52, 0xB0, 0x4F, 0xCD, 0x3A, 0xF1, 0x16, 0x36, 0x04, 0x18, 0x1E, 0x02, 0x4C, 0x04, 0x80, 0x28, + 0x34, 0x11, 0x0B, 0xD3, 0xB9, 0xC3, 0x8F, 0x47, 0x1D, 0x12, 0xA2, 0x10, 0x43, 0x83, 0x55, 0xA4, + 0x5A, 0x59, 0x82, 0x5F, 0xF9, 0x15, 0x11, 0x6E, 0x44, 0xA0, 0x38, 0x04, 0x36, 0x32, 0x12, 0xC8, + 0x31, 0xA8, 0x34, 0x30, 0x08, 0x1F, 0x30, 0x10, 0x85, 0x34, 0x81, 0x3D, 0x3E, 0x0E, 0x0E, 0xA9, + 0x10, 0x30, 0x83, 0x42, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x8F, 0xE4, 0x5F, 0x33, 0xCE, 0x03, 0xBA, + 0xC1, 0xB2, 0x33, 0x86, 0x89, 0x01, 0x15, 0x27, 0x92, 0x12, 0x08, 0xD3, 0x34, 0x0E, 0xEB, 0x26, + 0x80, 0xBF, 0x93, 0x25, 0xC0, 0x60, 0x24, 0x20, 0x34, 0x23, 0x4A, 0xB8, 0x35, 0xC7, 0xC2, 0xF0, + 0xD5, 0xD1, 0x72, 0x4E, 0xAE, 0x2E, 0x12, 0x5A, 0xAD, 0xE3, 0x19, 0x00, 0xCE, 0x95, 0xB8, 0xEA, + 0x26, 0xAE, 0xA0, 0x11, 0xC2, 0x93, 0xED, 0x55, 0xE1, 0x46, 0x04, 0xBE, 0x89, 0xF5, 0x01, 0x05, + 0xC0, 0x2D, 0x0A, 0x2B, 0x2D, 0x26, 0x8A, 0xED, 0xE9, 0x04, 0xEC, 0xBA, 0x38, 0xB4, 0x91, 0x5A, + 0x19, 0x1D, 0x21, 0x71, 0x9B, 0x45, 0x66, 0x49, 0x57, 0x16, 0x3F, 0xFC, 0xF8, 0x26, 0x8A, 0x92, + 0x52, 0xFD, 0x61, 0x47, 0x37, 0x5A, 0x31, 0x33, 0x52, 0x0E, 0x9C, 0xA6, 0xB5, 0xF8, 0xCE, 0x7C, + 0x56, 0x5D, 0x41, 0x4E, 0xFA, 0xC4, 0x1F, 0xF9, 0x42, 0xC5, 0x87, 0x71, 0x75, 0xA4, 0xD2, 0xBE, + 0xE3, 0x94, 0x7A, 0x35, 0x18, 0x9A, 0x18, 0x08, 0x38, 0x3A, 0x54, 0x3A, 0x05, 0x2B, 0x28, 0x02, + 0x2B, 0xA9, 0xEA, 0x45, 0x7C, 0x94, 0x01, 0x0F, 0xF5, 0xA6, 0x08, 0x82, 0x2C, 0xB0, 0xD5, 0xCC, + 0x32, 0xDE, 0xCC, 0x4D, 0xB9, 0x83, 0x23, 0xA2, 0x28, 0x85, 0x17, 0x9A, 0xDD, 0x68, 0x11, 0x87, + 0x20, 0x2C, 0x09, 0x3F, 0xFE, 0xC6, 0x7F, 0x9A, 0xD3, 0x46, 0x8B, 0x14, 0x1A, 0x01, 0x18, 0xC0, + 0x36, 0x1C, 0x46, 0xC9, 0x9B, 0x10, 0x13, 0x89, 0x0D, 0x62, 0x21, 0x94, 0xD6, 0xD1, 0xA8, 0xD2, + 0xFF, 0x36, 0xAA, 0x81, 0x01, 0x4D, 0xC8, 0x83, 0x43, 0x60, 0xD3, 0x8B, 0x3A, 0xD9, 0x03, 0x98, + 0x3A, 0xD0, 0x05, 0x50, 0x77, 0xB6, 0xDE, 0xCB, 0x44, 0x08, 0xA0, 0x95, 0x11, 0xC9, 0x80, 0x65, + 0x4D, 0x29, 0xA6, 0xA7, 0xA0, 0x39, 0x80, 0x53, 0x4B, 0x51, 0xC8, 0x07, 0x04, 0x05, 0x09, 0x37, + 0x9A, 0xAA, 0x7C, 0x87, 0x41, 0x20, 0xEB, 0x0B, 0x91, 0x65, 0x5E, 0x05, 0xA5, 0x53, 0x07, 0x3D, + 0x98, 0xA0, 0xFA, 0x68, 0xAF, 0x86, 0x34, 0xC3, 0xC4, 0x20, 0x40, 0x2C, 0xF9, 0xAB, 0x5A, 0xBB, + 0x23, 0x8C, 0xB3, 0x9B, 0xB3, 0x30, 0xCC, 0xA1, 0xFC, 0xA5, 0x56, 0xC6, 0x21, 0xD6, 0xC4, 0xBF, + 0xE4, 0x1F, 0xBF, 0xEE, 0xA6, 0xA0, 0xFA, 0xDF, 0x9C, 0x26, 0x0B, 0xBF, 0x1A, 0x86, 0x5C, 0x17, + 0x86, 0x1D, 0x9D, 0xCF, 0x5F, 0xDA, 0x97, 0x21, 0x59, 0x55, 0xE0, 0xB0, 0xFF, 0xD0, 0x20, 0x9A, + 0xE2, 0x83, 0x15, 0x19, 0x5D, 0xA9, 0x17, 0xFF, 0xE4, 0x61, 0x22, 0xAF, 0xE5, 0x02, 0x86, 0x2D, + 0x1E, 0xFF, 0xE9, 0x5B, 0xCC, 0xF3, 0x6C, 0x86, 0x56, 0x6D, 0x75, 0xE5, 0x9E, 0xA1, 0x9E, 0xA0, + 0x40, 0x61, 0x48, 0xCB, 0x59, 0xFC, 0xBB, 0xBA, 0x84, 0x21, 0x5A, 0x80, 0x00, 0x00, 0x00, 0x1C, + 0x1F, 0x76, 0xE0, 0x0E, 0x37, 0x9D, 0xD3, 0x7A, 0x28, 0x37, 0x31, 0x58, 0x00, 0x84, 0x5E, 0x64, + 0xD2, 0x59, 0x80, 0x05, 0xA6, 0x26, 0xFF, 0xFB, 0x92, 0x64, 0x0D, 0x86, 0x04, 0x13, 0x34, 0x4E, + 0xCB, 0x99, 0x62, 0xF4, 0x32, 0x24, 0x29, 0xC9, 0x1D, 0x26, 0x60, 0x12, 0xE8, 0xD3, 0x30, 0x0E, + 0xEF, 0x42, 0x80, 0xC4, 0x9A, 0x66, 0xF4, 0x31, 0x1A, 0xA8, 0x05, 0x88, 0xC1, 0x2B, 0x9C, 0xD1, + 0x08, 0xC8, 0x8C, 0xF2, 0x94, 0x08, 0x91, 0x82, 0x20, 0x29, 0xA2, 0x2D, 0x15, 0x6D, 0xE4, 0x24, + 0x8F, 0x0A, 0xE0, 0x3F, 0xAF, 0xD5, 0xE7, 0x71, 0xB9, 0x48, 0x97, 0x5B, 0x6E, 0xC1, 0x56, 0x9D, + 0x22, 0x62, 0x38, 0x23, 0x24, 0x91, 0x03, 0x20, 0xEB, 0x81, 0x3D, 0xAD, 0x40, 0xF9, 0x45, 0x25, + 0x8E, 0xC0, 0xF0, 0x10, 0x3C, 0x81, 0x99, 0x3F, 0x42, 0xC0, 0xA4, 0x09, 0x19, 0x37, 0xAD, 0x79, + 0x28, 0xD2, 0x54, 0x97, 0x84, 0x30, 0x7C, 0x75, 0x25, 0x16, 0x8E, 0x95, 0x56, 0x66, 0x76, 0x65, + 0xDB, 0xED, 0x27, 0xB6, 0xA8, 0x41, 0xC1, 0x63, 0xBA, 0x76, 0x6E, 0x74, 0xDB, 0xDA, 0xE7, 0xFF, + 0xA9, 0xF2, 0x00, 0x80, 0x02, 0x04, 0x00, 0x64, 0xB9, 0xFF, 0xFD, 0x06, 0xA0, 0x65, 0x04, 0x68, + 0xB8, 0x50, 0xC5, 0xBB, 0x13, 0x87, 0x35, 0x44, 0x8E, 0xA3, 0x0E, 0x4B, 0x1E, 0x73, 0xFC, 0x24, + 0x52, 0x47, 0x9F, 0xD1, 0x2B, 0x21, 0x13, 0x76, 0x77, 0xF3, 0x13, 0xEF, 0x0B, 0x03, 0x41, 0x53, + 0xBF, 0xAB, 0xE0, 0x24, 0xBE, 0x0B, 0x03, 0xE4, 0x06, 0xF1, 0xE7, 0xAD, 0x61, 0xDC, 0x87, 0x18, + 0xA9, 0xA1, 0xA5, 0x5C, 0x1A, 0x0D, 0x99, 0x31, 0x09, 0xCE, 0xBC, 0x07, 0xAD, 0x35, 0x45, 0xCE, + 0x63, 0x43, 0x55, 0x50, 0xD0, 0x3C, 0x05, 0x72, 0x11, 0x00, 0x33, 0xA7, 0x03, 0x16, 0x8D, 0x0D, + 0x8F, 0x33, 0xC1, 0x80, 0x08, 0xC8, 0x62, 0x8A, 0x87, 0x11, 0x47, 0x44, 0xF4, 0x19, 0x1A, 0x60, + 0x00, 0x8B, 0x00, 0x18, 0x02, 0x2C, 0x0C, 0x18, 0x1C, 0x79, 0x8B, 0x5B, 0x0E, 0x16, 0x64, 0x64, + 0xA9, 0x16, 0xAD, 0x2F, 0x1D, 0x0D, 0x0E, 0x29, 0x9D, 0x33, 0x10, 0x8D, 0x25, 0xF3, 0x86, 0x85, + 0x40, 0x11, 0x04, 0xC1, 0xA7, 0x9D, 0x78, 0x1A, 0xEA, 0x6B, 0x35, 0xE8, 0xCB, 0xF5, 0x61, 0xCC, + 0xB4, 0xCB, 0xA9, 0xDE, 0x47, 0x29, 0x99, 0x46, 0x5B, 0x8A, 0x85, 0x53, 0x3C, 0xB0, 0xE5, 0x2C, + 0x31, 0x7F, 0xFF, 0x73, 0x15, 0x6C, 0x65, 0x0C, 0x47, 0xAF, 0xE5, 0x0E, 0x5A, 0x92, 0x2B, 0x1A, + 0xCD, 0x9A, 0x9F, 0xEC, 0xCD, 0x4E, 0xFD, 0xDA, 0x3D, 0x4E, 0xF4, 0x00, 0x00, 0xA0, 0x00, 0x00, + 0x01, 0x70, 0x01, 0xB8, 0x07, 0xFF, 0xFF, 0xF0, 0x18, 0xCC, 0x8C, 0xEA, 0xEA, 0xDD, 0x92, 0x56, + 0x7C, 0xCD, 0xD6, 0xAD, 0xEA, 0xEA, 0x5A, 0x2A, 0x5D, 0x7C, 0x55, 0xD6, 0xB4, 0x43, 0xFF, 0x38, + 0x44, 0x90, 0x45, 0x04, 0x48, 0xD9, 0x3D, 0x20, 0x2C, 0x2D, 0x47, 0xA7, 0x4F, 0xD7, 0x80, 0xC5, + 0x23, 0x40, 0x1D, 0x98, 0xCB, 0x85, 0x73, 0x13, 0x08, 0x4D, 0xC6, 0xB4, 0x33, 0x88, 0xB8, 0x14, + 0x6E, 0x37, 0xC3, 0x04, 0xDA, 0x05, 0x03, 0x1D, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x07, 0xA4, 0x8C, + 0x34, 0xCC, 0x03, 0x9A, 0x7A, 0x70, 0x33, 0x04, 0xD9, 0x9B, 0x14, 0xC3, 0x76, 0x10, 0xD8, 0xD1, + 0x32, 0xAE, 0x69, 0xE9, 0xC0, 0xC4, 0x16, 0x64, 0x80, 0x53, 0x1D, 0xF0, 0x32, 0x79, 0xC4, 0x79, + 0x0D, 0x18, 0xB3, 0x99, 0x4C, 0x39, 0x39, 0x9D, 0x9C, 0x06, 0x42, 0x50, 0x33, 0x26, 0x74, 0x0E, + 0x68, 0x0E, 0x35, 0x13, 0x56, 0xB0, 0x80, 0x46, 0x20, 0x80, 0x10, 0x2A, 0x18, 0x03, 0x87, 0x91, + 0x26, 0x32, 0xA4, 0x50, 0xA0, 0xD0, 0x8F, 0x2F, 0x00, 0x72, 0x53, 0x14, 0x79, 0x89, 0x32, 0x87, + 0x21, 0xA1, 0x31, 0x55, 0xF0, 0xAC, 0x07, 0x93, 0x88, 0x91, 0x0F, 0x50, 0xB0, 0xA9, 0x90, 0xE4, + 0xFD, 0x86, 0x20, 0xDE, 0x1D, 0xEB, 0x0E, 0x02, 0xFD, 0xB9, 0x53, 0x53, 0x28, 0xD9, 0x31, 0xCB, + 0xE9, 0xFF, 0x2A, 0x2C, 0xE8, 0x26, 0xAF, 0x99, 0xA1, 0x43, 0x9F, 0xFC, 0xD9, 0xBB, 0xF5, 0x5A, + 0x72, 0x12, 0xF3, 0x45, 0x57, 0x6D, 0xD0, 0x5B, 0x51, 0xD6, 0xD1, 0xB5, 0x8B, 0xA1, 0xD1, 0xEC, + 0xE1, 0x40, 0x00, 0x02, 0xB0, 0x00, 0x10, 0xA8, 0x05, 0xFF, 0xE6, 0xB1, 0xB9, 0xE8, 0xD0, 0x9F, + 0x85, 0x92, 0xFB, 0x0B, 0x02, 0x1B, 0xBF, 0xFF, 0xC1, 0xC5, 0x0C, 0x28, 0xF1, 0x06, 0xBC, 0xA6, + 0xC1, 0xD7, 0x6C, 0x1D, 0x33, 0xF1, 0x49, 0xA0, 0xBB, 0x4F, 0xA3, 0x4A, 0x95, 0x58, 0x48, 0x46, + 0x0E, 0xA5, 0x17, 0xBE, 0x98, 0x1F, 0xD5, 0x52, 0x30, 0x41, 0x94, 0xCD, 0x8A, 0x33, 0x04, 0x00, + 0x8C, 0x80, 0x23, 0x33, 0x90, 0xC8, 0xE4, 0x25, 0x23, 0x00, 0x82, 0x0E, 0xB2, 0x18, 0x08, 0xBC, + 0x24, 0x40, 0xFA, 0x17, 0x30, 0xEC, 0x8C, 0xE1, 0x03, 0x6C, 0x19, 0x1D, 0x4D, 0x6A, 0x41, 0x82, + 0xEC, 0x9A, 0x7C, 0x50, 0x5A, 0x7B, 0x8B, 0x06, 0x67, 0xA1, 0x60, 0x2F, 0x6B, 0xA0, 0x5E, 0x11, + 0x20, 0xA4, 0xA0, 0xCB, 0xAB, 0x15, 0x62, 0x68, 0x30, 0x2C, 0x08, 0x0C, 0x14, 0x2E, 0xC0, 0xB6, + 0x89, 0x6A, 0xA7, 0x4D, 0xDD, 0x9A, 0xD2, 0xB6, 0xB2, 0xAB, 0x55, 0xA8, 0xF3, 0x18, 0xB0, 0x8B, + 0x4A, 0xFC, 0x52, 0xE2, 0x90, 0x94, 0xAB, 0x78, 0xAD, 0x38, 0x96, 0xF6, 0xAD, 0x32, 0x63, 0x31, + 0x46, 0xC9, 0xEC, 0x5E, 0x98, 0x61, 0x5B, 0x16, 0xFF, 0xFF, 0xFF, 0x4E, 0xA1, 0x4E, 0x93, 0xCD, + 0x91, 0x23, 0xC9, 0xDB, 0x69, 0xDB, 0xAB, 0x6D, 0x3A, 0xF0, 0x19, 0xD4, 0x40, 0x0C, 0xFF, 0xFF, + 0x4B, 0x45, 0x4E, 0xFC, 0xE0, 0xAB, 0x72, 0x2D, 0x47, 0x00, 0x92, 0xFE, 0xFF, 0xF2, 0x8D, 0x7C, + 0x95, 0x12, 0xE4, 0xEB, 0x08, 0xAA, 0xA5, 0xBE, 0x33, 0xA8, 0x7E, 0xEF, 0x50, 0x44, 0x58, 0x64, + 0x5C, 0x3A, 0x36, 0x7F, 0xA1, 0xD3, 0x9F, 0xB8, 0xB8, 0x4D, 0xB8, 0x83, 0xD5, 0x73, 0xD5, 0x90, + 0xC0, 0x64, 0xA3, 0x33, 0x2C, 0x0C, 0x02, 0x40, 0x03, 0x05, 0x4D, 0x78, 0x0F, 0x31, 0xC2, 0xFC, + 0xCF, 0x65, 0x23, 0xFA, 0x1A, 0x8C, 0x20, 0x2B, 0x30, 0xB0, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x8F, + 0x34, 0x53, 0x34, 0xCB, 0x83, 0x98, 0x7C, 0x40, 0x2F, 0xE5, 0xF9, 0x40, 0x05, 0x82, 0x6C, 0x12, + 0x50, 0xD3, 0x2A, 0x0E, 0x69, 0xED, 0x80, 0xC0, 0x15, 0xE5, 0xD4, 0x74, 0x89, 0xB1, 0x10, 0xD0, + 0x27, 0xA1, 0x18, 0xA4, 0x28, 0x09, 0x31, 0x58, 0x79, 0x62, 0x99, 0x70, 0x46, 0x61, 0xB1, 0xAB, + 0x0F, 0xC8, 0xB9, 0xE3, 0x80, 0x6E, 0xCB, 0x0E, 0x34, 0x44, 0xB5, 0x12, 0x19, 0x00, 0x51, 0xD5, + 0xAC, 0x1A, 0x0A, 0x8C, 0x83, 0x21, 0x16, 0x29, 0x6B, 0x9D, 0x90, 0x05, 0x05, 0x9C, 0x59, 0x44, + 0x8C, 0x65, 0xEC, 0xD5, 0xB8, 0x87, 0x0D, 0x9E, 0x45, 0x58, 0x98, 0xE8, 0x11, 0x3D, 0x5B, 0x9B, + 0x67, 0x6D, 0x71, 0x3C, 0xEF, 0xC7, 0xE2, 0xD5, 0x99, 0x96, 0x58, 0xA5, 0x72, 0xA3, 0x33, 0x44, + 0x7C, 0xAB, 0x51, 0xB0, 0x2D, 0xFF, 0xFF, 0xFF, 0xFE, 0x21, 0xB6, 0x2B, 0x62, 0x35, 0xED, 0x42, + 0xE0, 0xC9, 0x5A, 0xFA, 0x1C, 0x51, 0xCC, 0x08, 0x3C, 0xC3, 0x93, 0x60, 0x0B, 0xFF, 0xF9, 0x43, + 0x01, 0xFC, 0xD9, 0xDF, 0x98, 0x2C, 0x6D, 0xB6, 0x0C, 0xE3, 0x6F, 0xF7, 0x7D, 0x8E, 0x85, 0x5F, + 0x4B, 0x07, 0x9D, 0xFD, 0x75, 0xF3, 0xA8, 0x7B, 0x78, 0x0F, 0x11, 0xB3, 0x79, 0x91, 0x88, 0x49, + 0x6C, 0xEE, 0xDF, 0xF8, 0x57, 0xB1, 0x1D, 0x03, 0xA4, 0x20, 0x5A, 0xCB, 0xAA, 0x5F, 0x62, 0x06, + 0x59, 0x9E, 0x65, 0x26, 0x06, 0x0C, 0x19, 0x5D, 0x14, 0x65, 0xC7, 0xB1, 0x98, 0x94, 0xE1, 0x5E, + 0x89, 0xE7, 0xE7, 0x20, 0x65, 0x19, 0x81, 0xCF, 0xC6, 0xF6, 0x0E, 0x99, 0x40, 0x54, 0x0C, 0x6A, + 0x1D, 0xDD, 0xE6, 0x00, 0x51, 0x9E, 0x2E, 0x0B, 0xDC, 0x02, 0xB4, 0xC8, 0xC7, 0x4D, 0x99, 0xF1, + 0x06, 0x68, 0x02, 0xB5, 0x08, 0xC3, 0xB7, 0x42, 0x24, 0x40, 0xE1, 0x4B, 0xE5, 0xB4, 0x24, 0x12, + 0xC0, 0xD9, 0xD8, 0x14, 0x01, 0x68, 0x91, 0x20, 0xC0, 0xB8, 0x0C, 0x2E, 0x44, 0x34, 0x90, 0x52, + 0x43, 0xCB, 0xD7, 0xDA, 0xE4, 0x7A, 0x14, 0xF2, 0x2A, 0x3D, 0x8A, 0x44, 0x22, 0x0A, 0x57, 0xA6, + 0x1A, 0x15, 0x2B, 0x85, 0x0B, 0x12, 0x81, 0x08, 0x9C, 0xB1, 0x30, 0xEF, 0x69, 0x88, 0xF0, 0xA7, + 0xB7, 0xAB, 0x8F, 0xFE, 0xFB, 0xC7, 0xDD, 0x37, 0x7D, 0xC1, 0x8D, 0x58, 0x5B, 0x84, 0x3F, 0x84, + 0xE9, 0x2A, 0xFA, 0x02, 0x19, 0x57, 0xEE, 0x64, 0xC9, 0xEB, 0xE3, 0x95, 0x5F, 0x1D, 0x18, 0x0B, + 0x02, 0x17, 0xFE, 0x9C, 0xFE, 0x36, 0x45, 0x8A, 0x90, 0x93, 0x45, 0x36, 0xE1, 0x39, 0x29, 0x09, + 0xAD, 0x06, 0xA6, 0x85, 0x73, 0x07, 0xFA, 0x57, 0x6E, 0x2E, 0xBB, 0x0C, 0x62, 0x31, 0x3C, 0x11, + 0xE7, 0x53, 0x49, 0x14, 0xB4, 0x63, 0x7C, 0x8D, 0xE9, 0xFE, 0x3F, 0xC2, 0x1A, 0x31, 0x24, 0x18, + 0x55, 0x23, 0x01, 0xC3, 0x37, 0x45, 0x40, 0xC3, 0xF0, 0x8C, 0x23, 0xA7, 0xC8, 0x35, 0xFD, 0x23, + 0x6F, 0x19, 0x33, 0xFA, 0x83, 0x14, 0x4B, 0x34, 0x70, 0x63, 0x60, 0x87, 0xFF, 0xFB, 0x92, 0x64, + 0x0F, 0x0F, 0x74, 0x68, 0x34, 0xCB, 0x83, 0x79, 0x7B, 0x60, 0x32, 0x45, 0x59, 0x68, 0x24, 0x62, + 0xA4, 0x51, 0x54, 0xD3, 0x36, 0x0D, 0x65, 0xEE, 0xC0, 0xC4, 0x17, 0x67, 0x14, 0x91, 0x8A, 0x58, + 0x31, 0x34, 0x93, 0xAB, 0x79, 0x35, 0xE8, 0x10, 0xF8, 0x58, 0xB8, 0x4D, 0x60, 0xE6, 0x01, 0x03, + 0xA4, 0x9A, 0x15, 0x14, 0x30, 0xE9, 0xA6, 0xEA, 0x7B, 0x25, 0xB3, 0xFF, 0x1F, 0x52, 0x6A, 0xA4, + 0xB5, 0x1A, 0x3B, 0xF0, 0x99, 0xEA, 0x36, 0x90, 0xC9, 0xBC, 0xDC, 0xD5, 0xC9, 0x6F, 0x9B, 0x23, + 0x39, 0x66, 0xD5, 0x9C, 0xC6, 0x06, 0x90, 0x6F, 0x21, 0x6F, 0x90, 0xFA, 0x14, 0xD0, 0x1A, 0x5E, + 0xD5, 0x9A, 0x8A, 0x6F, 0xB1, 0xA1, 0x8F, 0x9F, 0x27, 0x15, 0x95, 0x9A, 0x2A, 0x4E, 0x3B, 0x45, + 0x64, 0xA3, 0xCA, 0x3E, 0x58, 0x9F, 0x73, 0x51, 0xBF, 0xC5, 0x9D, 0x49, 0x10, 0xE0, 0x10, 0x84, + 0xA1, 0x78, 0x67, 0x6C, 0x31, 0x13, 0xB8, 0x8C, 0x75, 0x96, 0xE5, 0x21, 0xF8, 0x68, 0x44, 0x08, + 0x40, 0x00, 0x00, 0x2D, 0x51, 0xFE, 0xFF, 0xF4, 0xA3, 0x2D, 0xE8, 0x50, 0xC8, 0x54, 0x18, 0x5E, + 0x70, 0x34, 0xD6, 0xA1, 0xFF, 0xB9, 0x73, 0xE6, 0x2B, 0xF0, 0x8C, 0xCE, 0x6A, 0xCD, 0x75, 0x8C, + 0xC0, 0xC6, 0x84, 0xAA, 0x5F, 0x4A, 0x7E, 0x87, 0x6E, 0xA8, 0xFC, 0x20, 0x8E, 0x0E, 0x9D, 0xD7, + 0x7F, 0x59, 0xDB, 0x0C, 0x30, 0xDD, 0xCD, 0xBA, 0x20, 0x60, 0x13, 0x24, 0x4C, 0xFC, 0x8F, 0x3D, + 0x65, 0xC0, 0x52, 0x07, 0xA1, 0x82, 0x42, 0x1B, 0x52, 0x86, 0x94, 0x10, 0x12, 0x39, 0xA4, 0xB8, + 0x08, 0x42, 0x2C, 0xD8, 0xE5, 0xAF, 0x25, 0x64, 0xED, 0x24, 0x1D, 0x38, 0xD1, 0x88, 0x00, 0x75, + 0x55, 0xA0, 0x44, 0x42, 0xE4, 0x7B, 0x12, 0x20, 0x1C, 0x02, 0xC4, 0x70, 0xD4, 0xDF, 0x4E, 0x93, + 0x2E, 0x64, 0xC4, 0xEC, 0x86, 0x15, 0x88, 0x78, 0x0C, 0xE2, 0xE6, 0x69, 0x98, 0xE6, 0xEE, 0x5B, + 0x55, 0xE6, 0x99, 0x04, 0x02, 0x51, 0x81, 0xA4, 0x57, 0x22, 0x31, 0x24, 0x4C, 0x43, 0x9D, 0x5E, + 0x21, 0xEA, 0xA6, 0xF5, 0x52, 0xC4, 0x0B, 0x4A, 0xE2, 0x9E, 0x99, 0x7C, 0xD3, 0x8F, 0xB8, 0xAD, + 0x86, 0x82, 0xC2, 0xAE, 0x8C, 0x6C, 0xF2, 0x66, 0x05, 0x0E, 0x85, 0x0A, 0xF9, 0x30, 0x2E, 0x0B, + 0x92, 0xD4, 0x49, 0xDB, 0x65, 0x60, 0x49, 0xAB, 0xDB, 0x59, 0x1F, 0xCC, 0x25, 0xA9, 0xAB, 0x8A, + 0xE5, 0xEE, 0x73, 0x46, 0x46, 0xD0, 0x50, 0x04, 0x30, 0xB3, 0xD0, 0x38, 0x36, 0xA2, 0x07, 0x2F, + 0x2A, 0x00, 0xA1, 0xDE, 0x08, 0xF8, 0xF9, 0x41, 0x0E, 0x4F, 0xFA, 0xBC, 0x89, 0x09, 0x3A, 0x32, + 0x91, 0x89, 0xFD, 0x08, 0xDA, 0xFD, 0xCF, 0x4C, 0xFC, 0x20, 0x6C, 0x10, 0xDC, 0x94, 0xA7, 0x60, + 0xA1, 0x49, 0xCA, 0x13, 0x84, 0x04, 0x3C, 0x49, 0xCC, 0x58, 0x63, 0x4A, 0xD4, 0x9B, 0xD1, 0xDD, + 0x62, 0xBB, 0x8C, 0xB8, 0x84, 0x34, 0x04, 0xBA, 0x39, 0x5C, 0x40, 0x26, 0x44, 0x88, 0xFF, 0xFB, + 0x92, 0x64, 0x10, 0x8F, 0x74, 0x82, 0x34, 0x4E, 0x83, 0x7A, 0xC0, 0xF0, 0x2E, 0xE2, 0xBA, 0x18, + 0x05, 0x26, 0x1A, 0x11, 0x80, 0xD1, 0x3A, 0x0D, 0xE9, 0xE9, 0x80, 0xC1, 0x93, 0xE6, 0xE0, 0x91, + 0x8A, 0x49, 0x9C, 0x99, 0xC3, 0x97, 0xC1, 0xCB, 0x8D, 0x28, 0x23, 0x92, 0x38, 0x31, 0xA9, 0xA3, + 0x02, 0x67, 0x87, 0x81, 0xA5, 0x02, 0xAA, 0x3D, 0x43, 0x8D, 0x87, 0xB8, 0xBA, 0x80, 0xE9, 0x5D, + 0xCF, 0xE4, 0x69, 0xCB, 0x7D, 0x20, 0x38, 0xAA, 0x7B, 0xCB, 0x8B, 0xA2, 0xE3, 0x3B, 0x14, 0xD0, + 0xF6, 0xEA, 0x3C, 0xCA, 0x25, 0x1A, 0x4C, 0xB9, 0x70, 0x58, 0xE9, 0x23, 0x75, 0x8A, 0xB4, 0x35, + 0x34, 0xA8, 0xC7, 0x1B, 0x66, 0xB0, 0xD4, 0x5A, 0xFD, 0x15, 0x7B, 0x1D, 0x8E, 0x3D, 0x54, 0xB2, + 0x97, 0xDA, 0x51, 0x14, 0xE4, 0x91, 0xCB, 0xEC, 0xC4, 0x7A, 0x33, 0x43, 0x5E, 0xE4, 0x46, 0x4F, + 0x83, 0xA8, 0x98, 0x16, 0xE5, 0xB6, 0x94, 0xC1, 0x9B, 0xAB, 0xEE, 0xDD, 0x6C, 0x94, 0xF8, 0xC1, + 0x97, 0xD0, 0xC0, 0x00, 0x00, 0x22, 0xA2, 0xEE, 0xF7, 0x03, 0xD4, 0xFE, 0x07, 0x64, 0x45, 0x91, + 0x8F, 0x05, 0x0C, 0xF0, 0xB1, 0xA0, 0x21, 0x85, 0x01, 0xAF, 0x13, 0xCE, 0xF5, 0xBF, 0xF9, 0x94, + 0x78, 0xA3, 0x4E, 0xA4, 0x60, 0x92, 0x63, 0x20, 0xAD, 0x98, 0xAB, 0x2E, 0x2A, 0x01, 0x40, 0xF6, + 0x66, 0xA6, 0xE6, 0x06, 0x10, 0x6C, 0x93, 0x86, 0x64, 0x1E, 0x18, 0xA2, 0x18, 0xA8, 0x6D, 0xA5, + 0x06, 0x46, 0x18, 0x70, 0x8E, 0x40, 0xC0, 0x60, 0x23, 0xC6, 0x95, 0xA0, 0x55, 0x11, 0x9D, 0x74, + 0x66, 0xC8, 0xA9, 0x90, 0x0C, 0x59, 0xBA, 0x72, 0x62, 0xCB, 0x1A, 0xB2, 0xC0, 0x65, 0x60, 0x05, + 0x6F, 0x70, 0x10, 0xB8, 0xB2, 0x45, 0x6B, 0x2C, 0xDA, 0x16, 0xB4, 0x92, 0xF2, 0x25, 0x62, 0xE2, + 0x40, 0x4B, 0x0D, 0x50, 0x5D, 0x92, 0x80, 0xAB, 0x23, 0x67, 0xF1, 0x38, 0x6B, 0x77, 0x12, 0xB8, + 0x6B, 0x38, 0xD0, 0xB6, 0x22, 0x60, 0xE4, 0x75, 0x17, 0x00, 0x24, 0x00, 0x42, 0x20, 0xC8, 0xC5, + 0x21, 0x2F, 0x46, 0x2F, 0xA0, 0xA3, 0xBE, 0x6F, 0x9B, 0xA6, 0x10, 0xB8, 0xCC, 0xCA, 0xB9, 0xDC, + 0x70, 0x8D, 0x88, 0xCE, 0xFA, 0x68, 0x4B, 0x8D, 0x30, 0x2B, 0x5F, 0xB7, 0x1B, 0x87, 0x08, 0x84, + 0xA9, 0x9E, 0x16, 0x23, 0xD9, 0x03, 0x87, 0xEC, 0xCD, 0x0A, 0x85, 0xEC, 0x21, 0x07, 0xBE, 0x59, + 0x19, 0x9F, 0x48, 0x86, 0x8D, 0x4B, 0x80, 0xC4, 0x30, 0x45, 0xAA, 0xC6, 0x2A, 0xE4, 0x9E, 0x85, + 0x01, 0x18, 0x98, 0x72, 0x55, 0x3E, 0x86, 0xFE, 0xC8, 0x6E, 0xA5, 0x6D, 0x0C, 0xE0, 0x82, 0xF8, + 0x21, 0x7A, 0x60, 0x85, 0x00, 0xCF, 0x8A, 0x10, 0x53, 0xFF, 0xFA, 0x3F, 0x2A, 0x80, 0x00, 0x03, + 0x84, 0x48, 0x01, 0x14, 0x1A, 0x19, 0x96, 0xDE, 0x63, 0x80, 0xC8, 0xD2, 0x60, 0xC7, 0x01, 0x03, + 0x33, 0x8F, 0x8C, 0x2E, 0x0F, 0x32, 0xB9, 0x24, 0xC8, 0x24, 0x78, 0xA3, 0x77, 0x63, 0x25, 0xC3, + 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x87, 0xA4, 0x1B, 0x33, 0x4F, 0x2B, 0x99, 0x7A, 0x72, 0x34, 0xA6, + 0x69, 0x55, 0x1C, 0xC7, 0x4A, 0x52, 0x00, 0xD3, 0x32, 0x0E, 0x69, 0xE9, 0xC0, 0xB2, 0x18, 0x27, + 0x34, 0x70, 0x8A, 0x60, 0xC3, 0xB8, 0x38, 0xB9, 0xC6, 0xFA, 0xA8, 0x0B, 0x4C, 0xE5, 0xEA, 0x18, + 0x9A, 0x75, 0xCF, 0x33, 0x00, 0x61, 0x29, 0x5A, 0x89, 0xE8, 0x1B, 0x02, 0x82, 0x82, 0x6B, 0xCC, + 0xFD, 0x39, 0x5F, 0x76, 0xD5, 0xBE, 0x20, 0x11, 0xB2, 0xB8, 0xEE, 0x44, 0xA7, 0x97, 0x67, 0xFE, + 0x66, 0x4A, 0xA3, 0x9E, 0x53, 0x96, 0xE3, 0x94, 0xC9, 0x1E, 0x4C, 0x88, 0xAD, 0x1E, 0xEA, 0xD6, + 0xC6, 0x06, 0x29, 0xDB, 0x7F, 0x5E, 0x3E, 0x66, 0x56, 0xB9, 0xB6, 0xB9, 0xA6, 0xD4, 0x53, 0x9A, + 0xBB, 0x93, 0x31, 0xF0, 0xBC, 0xCB, 0x3A, 0xF9, 0x39, 0x2F, 0xC9, 0x04, 0xCF, 0x37, 0x1E, 0xDF, + 0xB6, 0xD6, 0x55, 0x94, 0xA2, 0x00, 0x00, 0xCA, 0x82, 0xF1, 0x2E, 0xEB, 0x4A, 0xF3, 0x35, 0xB7, + 0x4B, 0x63, 0x10, 0x04, 0x08, 0x9F, 0x59, 0xDA, 0xBB, 0x32, 0x78, 0xDC, 0xDF, 0xB3, 0x55, 0xFF, + 0xDA, 0x3C, 0x73, 0xF2, 0xE2, 0xE2, 0x84, 0x85, 0xEC, 0x8A, 0x79, 0x11, 0x59, 0x4F, 0x95, 0x00, + 0xEF, 0xC4, 0xE0, 0x1C, 0xE8, 0x4D, 0x87, 0x08, 0x0C, 0x58, 0x31, 0x00, 0x78, 0xC0, 0x4E, 0x10, + 0x5A, 0x68, 0xD2, 0x8D, 0xD3, 0x1F, 0x00, 0x8C, 0x28, 0xD2, 0x35, 0x69, 0x88, 0xC9, 0x00, 0xE3, + 0x65, 0x25, 0x8C, 0x51, 0x13, 0x4A, 0x14, 0xEC, 0x19, 0x31, 0xEB, 0x8F, 0xF2, 0x81, 0xA0, 0x23, + 0x06, 0x50, 0xA8, 0xD6, 0x14, 0x30, 0x00, 0xC6, 0x01, 0x20, 0xF0, 0xA0, 0x51, 0xA2, 0x8C, 0x31, + 0x42, 0x5D, 0x04, 0x1B, 0x8C, 0x3B, 0xAC, 0x18, 0xB6, 0xA9, 0xD2, 0xD7, 0x52, 0x5D, 0x04, 0xB0, + 0x30, 0x8C, 0xD1, 0x79, 0x95, 0xFB, 0xF1, 0x12, 0xD4, 0xCC, 0x31, 0x48, 0x81, 0xF4, 0x5C, 0x88, + 0x40, 0x8E, 0x0F, 0xD2, 0x10, 0xD0, 0xAF, 0x2B, 0x50, 0xA6, 0x56, 0xB8, 0xAC, 0x28, 0x93, 0xB9, + 0x29, 0x0D, 0x6D, 0x58, 0xE7, 0xA4, 0x52, 0x78, 0xBF, 0x3F, 0x4A, 0x32, 0x14, 0xC5, 0x02, 0x1C, + 0x5F, 0x8C, 0x78, 0xD8, 0x82, 0x76, 0xA0, 0x63, 0x55, 0x60, 0xF5, 0x73, 0xC4, 0xC8, 0x73, 0x32, + 0xD3, 0x24, 0xDE, 0x0B, 0x33, 0xB7, 0xAB, 0xB7, 0x7B, 0xA0, 0x08, 0x07, 0x03, 0x90, 0x19, 0xFF, + 0x9F, 0x10, 0x48, 0x13, 0x28, 0xA7, 0x11, 0x1F, 0x26, 0xBF, 0xC0, 0xBC, 0xD9, 0x20, 0x23, 0x1B, + 0x9B, 0x35, 0xFD, 0xFE, 0xD0, 0xE6, 0xFE, 0xBF, 0xB6, 0xFE, 0x26, 0x06, 0x2A, 0xDF, 0xEB, 0x1C, + 0x72, 0xB7, 0xB6, 0x24, 0xDC, 0xAA, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x21, 0xAA, 0x15, 0x98, 0x44, + 0x46, 0x1E, 0x2C, 0x40, 0x0B, 0x10, 0x86, 0x15, 0x80, 0x26, 0x02, 0x86, 0xC6, 0x22, 0x08, 0xE6, + 0x21, 0x0C, 0x66, 0x3C, 0x96, 0xE0, 0x20, 0x9C, 0x40, 0x04, 0x1C, 0xB4, 0x62, 0x86, 0x1B, 0x38, + 0x10, 0xC9, 0xFF, 0xFB, 0x92, 0x64, 0x16, 0x06, 0x04, 0x32, 0x34, 0x4D, 0x3B, 0xBA, 0x4A, 0xF0, + 0x34, 0xE2, 0x09, 0xED, 0x18, 0x4F, 0x1A, 0x90, 0x34, 0xD1, 0x2E, 0x4E, 0xE1, 0x6D, 0x80, 0xC3, + 0x1E, 0xE7, 0xE8, 0xC0, 0x88, 0x0B, 0x83, 0x08, 0x71, 0xC5, 0x82, 0x46, 0x89, 0x19, 0x71, 0x9D, + 0xF5, 0x29, 0x28, 0x2A, 0xA8, 0xD4, 0xB9, 0xE2, 0x51, 0x26, 0x99, 0x18, 0x8D, 0xC2, 0xA7, 0x70, + 0x54, 0x88, 0x96, 0xD9, 0xA0, 0xA5, 0x82, 0x9C, 0xCD, 0xAF, 0xE7, 0xA8, 0x16, 0x57, 0x93, 0xFE, + 0xE4, 0xB1, 0x64, 0x11, 0x3D, 0x18, 0x46, 0xE9, 0x56, 0x0B, 0x1B, 0xBC, 0xB2, 0xBB, 0xA9, 0xCA, + 0x4D, 0x7D, 0x39, 0x3D, 0x16, 0x5A, 0x4E, 0x8D, 0xCF, 0x7F, 0x2A, 0x2D, 0x8A, 0x89, 0x60, 0xA8, + 0x94, 0x5F, 0xD9, 0x86, 0xC2, 0xD9, 0xCA, 0xDF, 0xB4, 0x5F, 0xD4, 0x7E, 0x2D, 0xA6, 0x9B, 0x67, + 0x50, 0x00, 0x02, 0x00, 0xA0, 0x00, 0x01, 0x80, 0x22, 0x9C, 0x01, 0x0F, 0xFF, 0x57, 0x0E, 0xAF, + 0xA3, 0x56, 0x97, 0x79, 0x6D, 0xBD, 0x61, 0x43, 0xC3, 0x80, 0x3F, 0x76, 0xC0, 0x3E, 0xA5, 0x21, + 0xC0, 0xD9, 0x0F, 0xB7, 0xC5, 0x3E, 0xE4, 0x59, 0x2C, 0xC2, 0xD4, 0x3F, 0xF5, 0x83, 0x32, 0x42, + 0x6A, 0x24, 0x62, 0xAE, 0x0F, 0x06, 0x09, 0x84, 0x1C, 0x04, 0x98, 0x6A, 0x80, 0x1F, 0x8F, 0x35, + 0x98, 0x3A, 0x0D, 0x26, 0xA9, 0x8A, 0xC7, 0x71, 0xA1, 0xC2, 0x01, 0x83, 0xE2, 0x81, 0x93, 0x25, + 0x51, 0x84, 0xE0, 0xAC, 0x7C, 0xC0, 0x00, 0x90, 0xC3, 0x71, 0x58, 0xC1, 0xE0, 0x0C, 0x1C, 0x63, + 0xDF, 0x07, 0xC2, 0x4C, 0x95, 0x07, 0x14, 0x28, 0x45, 0xC3, 0x24, 0x20, 0x7A, 0x56, 0xB9, 0x08, + 0x9C, 0xBE, 0x18, 0x2B, 0x64, 0x50, 0xC0, 0xD5, 0xDA, 0xB8, 0x92, 0x4A, 0x10, 0xE5, 0x08, 0xC6, + 0xCF, 0x5A, 0x88, 0x54, 0x2D, 0x2A, 0x7E, 0x9D, 0x93, 0x32, 0xAB, 0x0B, 0x25, 0xB9, 0x4D, 0x80, + 0x01, 0x84, 0x1C, 0xA1, 0x8B, 0x3D, 0xA4, 0xE2, 0x73, 0x39, 0xB4, 0x73, 0x54, 0x58, 0xBE, 0xD8, + 0x36, 0x6D, 0x4B, 0x51, 0x64, 0xD7, 0xE8, 0xA3, 0xCB, 0x51, 0x93, 0x00, 0xB7, 0x46, 0xC7, 0xC7, + 0x69, 0x6B, 0x52, 0x76, 0x8D, 0x7F, 0xA7, 0x15, 0xC0, 0x00, 0x01, 0x45, 0x50, 0x02, 0x52, 0x29, + 0xDE, 0x84, 0x9F, 0x84, 0x70, 0x6E, 0xD3, 0x22, 0x12, 0x49, 0xD5, 0x09, 0x3C, 0xAB, 0x4D, 0x7F, + 0xA3, 0xA1, 0x3F, 0x3B, 0xFF, 0xF3, 0x5F, 0x5D, 0x7F, 0x5F, 0xFF, 0xF3, 0x7F, 0xFF, 0x10, 0xEE, + 0x2C, 0x3D, 0xD1, 0xE4, 0xEE, 0x67, 0xBB, 0x1A, 0x80, 0x00, 0x00, 0xC2, 0x80, 0x17, 0xF4, 0xBE, + 0xC6, 0x0E, 0x9E, 0x67, 0x14, 0x74, 0x02, 0x20, 0xFC, 0xC0, 0x50, 0x50, 0xCA, 0x28, 0x58, 0xC4, + 0x03, 0x00, 0xC1, 0x20, 0xD0, 0xC8, 0xA3, 0x4C, 0xC7, 0xC0, 0xA4, 0xC3, 0xC0, 0x5C, 0xC5, 0xE0, + 0x88, 0x64, 0x02, 0x33, 0x24, 0x6E, 0x30, 0x01, 0x02, 0xD3, 0x04, 0x87, 0x9D, 0x04, 0x22, 0x4B, + 0xD4, 0x0C, 0x12, 0x0C, 0xFF, 0xFB, 0x92, 0x64, 0x1E, 0x04, 0x04, 0x0E, 0x2E, 0x4B, 0x3B, 0xBA, + 0x53, 0x60, 0x34, 0x41, 0x3A, 0x1D, 0x18, 0xA7, 0x00, 0x8F, 0x68, 0xBD, 0x2E, 0x4E, 0xE9, 0x4B, + 0xD0, 0xC4, 0x17, 0xE8, 0xA8, 0x20, 0x89, 0xFB, 0x54, 0x58, 0xD5, 0xA2, 0xEB, 0xA3, 0x6A, 0x55, + 0xC0, 0xA4, 0x41, 0x1D, 0xF8, 0x65, 0x20, 0x57, 0xA6, 0x23, 0x80, 0x50, 0x48, 0xD1, 0x48, 0x42, + 0xCC, 0xCD, 0x41, 0x0C, 0x2A, 0x53, 0x1F, 0x8C, 0xB2, 0xD6, 0x8E, 0xDF, 0x18, 0xE0, 0x60, 0xA0, + 0x88, 0x3E, 0xAA, 0xAC, 0xCE, 0x6D, 0x57, 0x82, 0xF9, 0x31, 0x70, 0x5B, 0x3F, 0xA7, 0x77, 0xFA, + 0x9B, 0x4B, 0x3F, 0xFB, 0x8C, 0x80, 0xBD, 0xF9, 0xEF, 0xFE, 0x7D, 0xF3, 0xC9, 0xA5, 0x08, 0x04, + 0x00, 0x00, 0x00, 0x31, 0xDA, 0x03, 0x02, 0x03, 0x6B, 0x28, 0x5A, 0xD8, 0x50, 0xFD, 0x8B, 0x2D, + 0xCA, 0x1E, 0x77, 0x7E, 0x5A, 0x56, 0x2A, 0xE7, 0x69, 0xF7, 0x44, 0xD5, 0x85, 0x81, 0x5F, 0x79, + 0xED, 0x25, 0xD6, 0x1E, 0x15, 0x28, 0x90, 0xA8, 0xB1, 0x43, 0xD6, 0x8B, 0x07, 0x24, 0x4C, 0xBA, + 0x1B, 0x92, 0x00, 0x18, 0x00, 0xB0, 0x12, 0x5F, 0x63, 0x07, 0x86, 0x63, 0x58, 0x78, 0x13, 0x19, + 0xC1, 0x20, 0x30, 0x04, 0x63, 0x49, 0x70, 0x60, 0xE1, 0x72, 0x10, 0x32, 0x98, 0xDA, 0x44, 0x18, + 0xF4, 0x50, 0x18, 0x6C, 0x27, 0x1C, 0x1E, 0x46, 0x04, 0xF9, 0xE1, 0x5A, 0x6B, 0x11, 0x15, 0x64, + 0x1B, 0x31, 0xA8, 0x42, 0x28, 0x09, 0xA4, 0xB0, 0xB0, 0x49, 0x90, 0x20, 0x45, 0x9E, 0x90, 0xC9, + 0xCE, 0xE1, 0xB4, 0x0C, 0xDF, 0xE1, 0x61, 0x6D, 0x06, 0xF2, 0xEB, 0x6D, 0xE0, 0xA1, 0x01, 0x05, + 0xDA, 0xB9, 0x23, 0x6C, 0x39, 0x94, 0xB2, 0xA5, 0xED, 0x27, 0x6C, 0x8D, 0xC9, 0x9F, 0xAB, 0xF4, + 0xAC, 0x6C, 0x8D, 0x21, 0x7D, 0x4A, 0x01, 0xD1, 0xD6, 0x0D, 0x49, 0x87, 0x84, 0x8B, 0x3C, 0xFF, + 0xFA, 0x10, 0x37, 0xFC, 0x54, 0x10, 0x88, 0x44, 0x24, 0x12, 0x79, 0xFD, 0x5A, 0x5C, 0x04, 0x01, + 0x05, 0x39, 0x6C, 0x00, 0x20, 0x01, 0x9B, 0x9C, 0x6A, 0x6E, 0x2A, 0x46, 0x52, 0x8D, 0xD9, 0xB7, + 0xFD, 0x98, 0xDD, 0x52, 0x82, 0x68, 0xCC, 0x4A, 0x59, 0xA9, 0x72, 0xFD, 0x46, 0xC4, 0x2E, 0xFF, + 0x1D, 0x8C, 0x76, 0xB8, 0x6B, 0xE1, 0x54, 0xC4, 0xD9, 0xF3, 0xB1, 0x5F, 0x6D, 0x7F, 0x2A, 0x00, + 0xED, 0x04, 0xA3, 0x0E, 0x02, 0x13, 0x0B, 0xF0, 0x59, 0x31, 0x46, 0x53, 0x83, 0x79, 0x90, 0x06, + 0xA6, 0x06, 0xE5, 0x2F, 0x19, 0x31, 0x96, 0x6E, 0x71, 0x21, 0xB7, 0x5D, 0x66, 0xC5, 0x60, 0x99, + 0x50, 0x1C, 0x65, 0xB1, 0xA8, 0x89, 0x64, 0x4F, 0x99, 0x34, 0x41, 0xBC, 0xC5, 0x48, 0x63, 0x06, + 0x11, 0x8C, 0xCE, 0x2A, 0x1A, 0x4C, 0x05, 0x05, 0xA6, 0x45, 0x0A, 0x9A, 0x39, 0x82, 0xB1, 0x00, + 0x02, 0x5B, 0x25, 0x67, 0x49, 0xB5, 0x3C, 0x91, 0x80, 0x34, 0x01, 0x6D, 0x35, 0x78, 0xB8, 0x32, + 0x81, 0x81, 0x92, 0x44, 0x04, 0xC2, 0xFF, 0xFB, 0x92, 0x64, 0x2B, 0x8C, 0x04, 0xEF, 0x2F, 0xC9, + 0x93, 0xDC, 0xC8, 0xE0, 0x2D, 0x06, 0xCA, 0x4C, 0x1C, 0x02, 0xD1, 0x94, 0x30, 0xC9, 0x28, 0x2E, + 0xF3, 0x25, 0x50, 0xBD, 0x16, 0xE9, 0x34, 0x60, 0x89, 0xDA, 0x5C, 0x05, 0x00, 0x5F, 0x68, 0xC6, + 0x24, 0x11, 0x70, 0x83, 0x81, 0xB1, 0x0D, 0x80, 0x5F, 0x41, 0xC6, 0xC0, 0x08, 0x29, 0x80, 0xAB, + 0xF1, 0x91, 0xE5, 0xB1, 0x46, 0xA7, 0x82, 0x3D, 0x62, 0xC0, 0x92, 0xC2, 0xDE, 0xE2, 0x90, 0x47, + 0x69, 0xF2, 0xA4, 0xE6, 0xB5, 0xAA, 0xAA, 0xC8, 0x5E, 0x39, 0x36, 0xF0, 0xE7, 0xFF, 0xF3, 0xF2, + 0x2A, 0x28, 0x34, 0xC5, 0x22, 0x08, 0x14, 0x31, 0x12, 0x2C, 0xE4, 0x84, 0x04, 0xA1, 0xBF, 0xF5, + 0xD3, 0x00, 0x00, 0x00, 0x01, 0x00, 0xFE, 0x00, 0x22, 0x2C, 0x6F, 0x56, 0xA0, 0xFB, 0x73, 0xCD, + 0x64, 0xB9, 0xB6, 0xED, 0xA6, 0xB6, 0xFF, 0xF4, 0x5E, 0xA7, 0xBD, 0x6A, 0x64, 0xAF, 0xFA, 0x8A, + 0xB1, 0x1C, 0x0B, 0xEE, 0x71, 0x9E, 0x9C, 0x17, 0x0D, 0xB7, 0xA8, 0xF4, 0xFF, 0xD6, 0x02, 0x3D, + 0xE6, 0x05, 0x00, 0xE6, 0x16, 0x0B, 0x66, 0x7C, 0xB3, 0x87, 0x9E, 0x3A, 0x46, 0x84, 0x1B, 0x86, + 0xE4, 0x99, 0x9F, 0x59, 0xE2, 0x77, 0x32, 0xE9, 0xB7, 0x58, 0x06, 0x99, 0x89, 0x1A, 0x40, 0x36, + 0x00, 0x5F, 0x98, 0xFC, 0x76, 0x63, 0x3D, 0xD1, 0xCE, 0x36, 0x47, 0x82, 0x83, 0x1A, 0x7C, 0x7E, + 0x20, 0x2F, 0x8D, 0x28, 0x80, 0x80, 0x90, 0xB8, 0x21, 0x34, 0x81, 0x4E, 0x8C, 0xCE, 0x5E, 0x33, + 0x39, 0xC2, 0x67, 0xDD, 0xB1, 0x08, 0x40, 0x22, 0xC5, 0x12, 0x08, 0x14, 0xC3, 0x94, 0x05, 0x39, + 0x64, 0x09, 0x0E, 0x34, 0x4D, 0x10, 0x9A, 0x84, 0xEA, 0x73, 0x70, 0x96, 0x24, 0xC4, 0x98, 0xA0, + 0x24, 0xB0, 0xE2, 0xD1, 0x10, 0x00, 0x5B, 0x57, 0x2E, 0x92, 0x28, 0x2C, 0x94, 0x33, 0x55, 0xF1, + 0xA9, 0x15, 0xC7, 0x56, 0x4C, 0xC2, 0x59, 0x6D, 0x6A, 0xAD, 0xC9, 0xBB, 0x3C, 0x95, 0x23, 0x12, + 0xCE, 0x7F, 0xEE, 0x57, 0x2A, 0x59, 0xD7, 0xBF, 0x99, 0xF2, 0x6E, 0xFF, 0xF3, 0xAF, 0x1C, 0xA6, + 0x9C, 0xB7, 0x8E, 0x62, 0xAC, 0xC7, 0xF5, 0xBF, 0x95, 0xCB, 0x1C, 0x2A, 0x6B, 0xF4, 0xFD, 0x8D, + 0x50, 0x00, 0x00, 0x02, 0x02, 0x8E, 0x50, 0x32, 0x2F, 0xBD, 0x3D, 0x7B, 0xB4, 0xF3, 0xEE, 0x03, + 0xAD, 0x0D, 0xF2, 0x07, 0xA2, 0xD2, 0x2A, 0xEB, 0xFF, 0xD6, 0xBC, 0xEB, 0xA1, 0x35, 0x3B, 0xF5, + 0x64, 0x45, 0x9C, 0x13, 0xFE, 0x78, 0x43, 0x9A, 0x27, 0xDB, 0xFD, 0x81, 0x5B, 0xA8, 0x4D, 0x80, + 0x00, 0x00, 0x01, 0x80, 0x22, 0x1A, 0x7C, 0x0C, 0x13, 0xA6, 0x5D, 0xC1, 0xC6, 0xA8, 0x11, 0x26, + 0x3D, 0x09, 0xA6, 0x09, 0x87, 0xC7, 0x3D, 0x49, 0xA7, 0xB5, 0xA2, 0x20, 0x03, 0x3C, 0xC9, 0xF0, + 0x3C, 0xD4, 0x61, 0x34, 0xC4, 0xB0, 0xB8, 0x40, 0x3B, 0x18, 0x6A, 0x70, 0x1C, 0xFE, 0x2E, 0x1A, + 0xC8, 0xC3, 0x98, 0x82, 0x60, 0x19, 0x5E, 0x23, 0xFF, 0xFB, 0x92, 0x64, 0x1C, 0x86, 0x45, 0x4C, + 0x34, 0xCC, 0x3B, 0xBA, 0x7C, 0x40, 0x2D, 0x01, 0x1A, 0x8D, 0x24, 0x62, 0x08, 0x92, 0x34, 0xD5, + 0x3A, 0x0F, 0x6D, 0xEB, 0xC0, 0xC0, 0x17, 0x67, 0xF0, 0x91, 0x89, 0x38, 0x98, 0xC2, 0x02, 0x06, + 0x05, 0x4B, 0x78, 0xCA, 0x72, 0x5A, 0x80, 0xA6, 0x28, 0x05, 0x33, 0xA6, 0x4B, 0x21, 0x21, 0x1D, + 0x12, 0x75, 0xD7, 0x04, 0x4C, 0x0B, 0x91, 0x43, 0x89, 0x84, 0xA8, 0x34, 0xB1, 0x66, 0xAF, 0x05, + 0xCC, 0xE9, 0x8B, 0x01, 0x30, 0xE8, 0xDD, 0x5B, 0xF1, 0xA1, 0x42, 0x25, 0x05, 0xA3, 0xC3, 0x82, + 0x06, 0x56, 0x9E, 0xB2, 0xE9, 0x00, 0x9B, 0xE0, 0xE1, 0xEA, 0xB9, 0xA9, 0xB4, 0x87, 0xAA, 0x58, + 0xD0, 0xC3, 0xCE, 0x8D, 0xC1, 0x1C, 0x07, 0x6D, 0x1E, 0xAA, 0xD3, 0xF8, 0xF2, 0x56, 0x34, 0x32, + 0x4F, 0xF0, 0xA7, 0x78, 0xE7, 0xA3, 0xF2, 0x9A, 0xC9, 0xD0, 0x7D, 0xE4, 0x42, 0x8C, 0x41, 0xA9, + 0x48, 0x37, 0xFE, 0xA6, 0x9C, 0xCD, 0x4B, 0x03, 0x83, 0xFF, 0x6E, 0xB9, 0x0B, 0xB0, 0x00, 0x00, + 0x00, 0x25, 0x35, 0x30, 0x01, 0x99, 0x04, 0x2E, 0xEB, 0x4E, 0xB6, 0xD1, 0x48, 0x01, 0xD2, 0x9B, + 0x4A, 0xBE, 0x0A, 0x3C, 0x9A, 0x1D, 0x45, 0xF2, 0x45, 0x69, 0xB0, 0xF9, 0x45, 0xBD, 0xF7, 0x66, + 0x27, 0x15, 0x45, 0xA7, 0xFF, 0x9D, 0xA4, 0x21, 0x49, 0x69, 0x32, 0xE7, 0x19, 0x01, 0xD3, 0x0A, + 0xE0, 0x8C, 0x08, 0x13, 0x00, 0x70, 0x21, 0x08, 0xC3, 0x60, 0xC0, 0x75, 0x06, 0x8C, 0x4D, 0x41, + 0xC8, 0x1C, 0x0D, 0xA1, 0x00, 0x48, 0x62, 0x4A, 0x0B, 0xA0, 0x22, 0xA3, 0x03, 0x33, 0x1C, 0x63, + 0x3B, 0x72, 0x41, 0xE2, 0xD3, 0x30, 0x39, 0x30, 0x92, 0x73, 0x64, 0x1E, 0x65, 0xAC, 0xB0, 0x46, + 0xA0, 0x4C, 0x62, 0xC9, 0x1F, 0xF0, 0x70, 0xAA, 0x48, 0xDC, 0x55, 0x12, 0xB0, 0xE0, 0xC0, 0x55, + 0x07, 0x61, 0x46, 0x14, 0x9E, 0x9F, 0x71, 0xB4, 0x6F, 0x56, 0xAC, 0x22, 0xC5, 0x80, 0x15, 0x34, + 0x7D, 0xED, 0xA1, 0x82, 0x2D, 0xCE, 0x25, 0xB1, 0x2B, 0x22, 0x99, 0x4A, 0x69, 0x42, 0x80, 0x8D, + 0x0E, 0x8D, 0x6B, 0x33, 0x30, 0x29, 0x92, 0xDA, 0xD8, 0x9F, 0x30, 0x47, 0x76, 0xB9, 0x35, 0xF1, + 0xDB, 0xA0, 0xFE, 0x4F, 0x1C, 0x36, 0xF6, 0x14, 0xDE, 0x57, 0xB3, 0xF4, 0x52, 0xAA, 0xCC, 0x22, + 0x9A, 0xD7, 0x68, 0x1B, 0xFF, 0xB4, 0x6B, 0x30, 0x8B, 0x83, 0xAD, 0xB3, 0x40, 0x00, 0x04, 0x80, + 0x92, 0x93, 0xFE, 0xD2, 0x15, 0x08, 0xC9, 0x3B, 0xC0, 0x23, 0x58, 0x42, 0xC5, 0xB8, 0xA8, 0x0C, + 0x82, 0x0B, 0xD0, 0x1D, 0x17, 0xE5, 0x11, 0x29, 0xC2, 0xE8, 0x40, 0x92, 0x1F, 0x06, 0x1B, 0xFD, + 0xAC, 0xF5, 0xFF, 0x7D, 0x2D, 0x93, 0x39, 0x70, 0x22, 0x3B, 0xCD, 0x2A, 0xD3, 0x5B, 0x30, 0x90, + 0x18, 0xD8, 0xF2, 0x33, 0x46, 0x04, 0xE1, 0x46, 0x02, 0x36, 0x1F, 0xBD, 0x72, 0x6F, 0x00, 0xC1, + 0x8D, 0x43, 0xC6, 0x37, 0x2D, 0x04, 0xA4, 0x4B, 0xE0, 0x61, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0F, + 0x94, 0x73, 0x34, 0xCE, 0x03, 0x9A, 0x7C, 0x40, 0x32, 0x23, 0x69, 0xDB, 0x25, 0x49, 0x44, 0x11, + 0x4C, 0xD1, 0x38, 0x0E, 0xED, 0xEB, 0xC8, 0xC1, 0x17, 0xA7, 0x10, 0xB3, 0x09, 0xD0, 0xA2, 0x20, + 0x09, 0x4A, 0x7A, 0x01, 0xF1, 0x88, 0x00, 0xC6, 0x25, 0x22, 0x10, 0x80, 0x85, 0xB1, 0x89, 0x30, + 0xD2, 0x82, 0xDB, 0x00, 0xD6, 0x19, 0xAC, 0x34, 0x22, 0x74, 0x92, 0x11, 0x67, 0xF4, 0xC0, 0x97, + 0x5B, 0x8C, 0x85, 0x94, 0x19, 0x3B, 0x48, 0x1D, 0x1B, 0x47, 0x92, 0x80, 0xB5, 0xEA, 0x2A, 0xA8, + 0x42, 0x17, 0xFE, 0x0F, 0x19, 0x2C, 0x34, 0x8E, 0xBC, 0x50, 0xC4, 0xB4, 0x07, 0x68, 0x76, 0xE2, + 0x08, 0x6E, 0xDB, 0x3D, 0xA9, 0xDB, 0x02, 0xF0, 0x50, 0x71, 0x60, 0x9F, 0x05, 0xF6, 0x3B, 0xC8, + 0x27, 0x95, 0x31, 0x76, 0x8D, 0x64, 0x5D, 0xD6, 0x76, 0xE4, 0xAF, 0x9B, 0x1B, 0x45, 0x6F, 0xC5, + 0x55, 0xE1, 0x98, 0xA9, 0x45, 0x5D, 0xDF, 0xFE, 0x54, 0x2A, 0x69, 0xA1, 0x0B, 0x7C, 0xC4, 0x00, + 0x05, 0x80, 0x00, 0x82, 0x2F, 0xDF, 0xD7, 0x6F, 0x8C, 0x93, 0x84, 0xE3, 0xF5, 0xAF, 0xE3, 0x6B, + 0xB6, 0x2C, 0x9B, 0x51, 0x35, 0xBE, 0x62, 0x4F, 0xBF, 0xEA, 0xB2, 0x42, 0xB2, 0xA7, 0xFC, 0x13, + 0x9E, 0x4C, 0x0C, 0xBF, 0xA6, 0x63, 0xA5, 0xE7, 0xBE, 0x2E, 0xA7, 0xC3, 0xC8, 0x6C, 0xEB, 0xF9, + 0x46, 0xE2, 0x87, 0x86, 0x00, 0x05, 0xE6, 0x13, 0x28, 0xA6, 0x1E, 0x83, 0xE2, 0x40, 0xC0, 0xE0, + 0x18, 0x6A, 0xE5, 0xAE, 0x64, 0xE8, 0x26, 0x60, 0xF8, 0x14, 0x59, 0xD3, 0x48, 0x44, 0x83, 0x0C, + 0x03, 0x31, 0x3C, 0x20, 0x74, 0xD1, 0xE0, 0xFE, 0x8A, 0x88, 0x15, 0x40, 0x4C, 0x14, 0xC0, 0xC0, + 0x0F, 0x42, 0x01, 0x9A, 0xF8, 0x85, 0x98, 0x31, 0x76, 0xD4, 0xA8, 0xAA, 0x84, 0x06, 0x3B, 0x8E, + 0x40, 0x24, 0x07, 0x3B, 0x81, 0x13, 0x44, 0xC0, 0x46, 0xDD, 0x3A, 0x8E, 0xDC, 0x5E, 0xB5, 0x58, + 0x28, 0x1C, 0x31, 0x6A, 0x2C, 0x23, 0x02, 0x1E, 0x46, 0xA6, 0x7A, 0x60, 0x71, 0xE8, 0x88, 0xC7, + 0x09, 0x43, 0xE1, 0xDA, 0xDB, 0x1F, 0xCA, 0x81, 0x8F, 0xF6, 0x2F, 0xAB, 0x5A, 0xEA, 0x9D, 0xB5, + 0x01, 0xA9, 0x5A, 0x23, 0xE9, 0xAD, 0xD3, 0x9F, 0xEC, 0x3F, 0xC3, 0x72, 0x4E, 0x59, 0x22, 0x20, + 0x09, 0x49, 0xFE, 0x1F, 0x51, 0x3A, 0x86, 0x47, 0x6F, 0x55, 0x2C, 0xE0, 0x02, 0x91, 0x67, 0x98, + 0x99, 0xDA, 0x2F, 0x0D, 0x2E, 0xFF, 0x8F, 0xD0, 0x34, 0x91, 0x45, 0xE6, 0x0B, 0x1D, 0x4C, 0x63, + 0x3F, 0x10, 0x5B, 0x20, 0x63, 0xC1, 0x03, 0xA0, 0x11, 0xA5, 0x2F, 0xEA, 0x64, 0xA1, 0xB4, 0x46, + 0x2D, 0xD9, 0x5D, 0xE5, 0xF6, 0x6D, 0xEC, 0x51, 0x5D, 0x27, 0xC7, 0xD5, 0x80, 0x00, 0x03, 0xBC, + 0x30, 0x00, 0x01, 0x41, 0x43, 0x26, 0x14, 0x50, 0x89, 0x0C, 0x98, 0x3E, 0x30, 0xFC, 0x80, 0x35, + 0x12, 0x9C, 0x32, 0x94, 0x50, 0x31, 0x48, 0x4D, 0x30, 0xA8, 0x23, 0x34, 0xFF, 0xFB, 0x92, 0x64, + 0x10, 0x07, 0x14, 0x88, 0x34, 0x4D, 0xAB, 0xBA, 0x7C, 0xB0, 0x31, 0xA6, 0x69, 0xAB, 0x1C, 0x62, + 0xB0, 0x50, 0xF4, 0xD1, 0x39, 0x0E, 0x65, 0xB2, 0xD0, 0xBE, 0x17, 0xA6, 0x24, 0x53, 0x8D, 0xB9, + 0x71, 0x35, 0x12, 0x16, 0x8C, 0x05, 0x00, 0x42, 0x2D, 0xE3, 0x02, 0x1A, 0x00, 0x50, 0x78, 0x61, + 0xB8, 0x5A, 0xDD, 0xC6, 0x9D, 0xA5, 0xE8, 0xB3, 0x01, 0xA4, 0x21, 0x8F, 0xA1, 0x0A, 0x9B, 0x43, + 0xA1, 0x56, 0x84, 0xEA, 0xA7, 0xAD, 0x91, 0x0C, 0x12, 0x66, 0xBD, 0x1F, 0x72, 0x61, 0x20, 0x62, + 0x6A, 0x95, 0x65, 0x82, 0x80, 0x45, 0x2F, 0xD8, 0x0E, 0x5C, 0xBF, 0x22, 0x2D, 0xD4, 0xC7, 0x8E, + 0x7B, 0x17, 0xD9, 0x7E, 0x49, 0xD2, 0x2A, 0xD9, 0x7A, 0x0C, 0xA5, 0xC7, 0xF8, 0xFE, 0x4A, 0x32, + 0x62, 0x08, 0x68, 0x6B, 0xE7, 0x78, 0xDD, 0x52, 0xBF, 0xC4, 0x77, 0xF9, 0x98, 0x64, 0x6B, 0xB3, + 0x6F, 0xD1, 0xCD, 0x55, 0x09, 0xE8, 0x48, 0xDD, 0x6F, 0xC8, 0xB7, 0xB6, 0xF0, 0xDC, 0x72, 0x6F, + 0x73, 0x28, 0x00, 0x34, 0x00, 0x40, 0x05, 0x88, 0x01, 0x5C, 0xD2, 0x5A, 0x04, 0x4E, 0xBD, 0x71, + 0x48, 0x3B, 0x2D, 0xD4, 0x54, 0x63, 0xFF, 0x43, 0xA2, 0x55, 0x63, 0x61, 0x43, 0x8D, 0xFF, 0xF2, + 0x67, 0x75, 0xD8, 0xF7, 0x4B, 0xA7, 0x0A, 0x6C, 0x3B, 0x42, 0x05, 0x72, 0xA8, 0x10, 0x07, 0x74, + 0x18, 0x16, 0x34, 0x00, 0x23, 0xF3, 0x50, 0x30, 0x48, 0x60, 0x43, 0x20, 0x05, 0x86, 0x8B, 0x8E, + 0x62, 0x63, 0xF1, 0xBC, 0xFF, 0x00, 0x78, 0x21, 0x87, 0x4D, 0x02, 0x03, 0x11, 0x93, 0x74, 0x06, + 0x08, 0x14, 0x18, 0x1C, 0x6A, 0x67, 0x21, 0xC1, 0xA9, 0x30, 0xE6, 0x04, 0x00, 0x98, 0x14, 0x12, + 0x0A, 0x22, 0x99, 0x98, 0xA4, 0x0E, 0x05, 0xB7, 0x60, 0x10, 0x88, 0xD5, 0x60, 0xA5, 0x9F, 0x21, + 0x20, 0x80, 0x34, 0xAB, 0x36, 0x84, 0x64, 0x0B, 0x7D, 0x56, 0xE1, 0x2C, 0x88, 0x1C, 0xA5, 0x8E, + 0x62, 0x3F, 0x2A, 0xCB, 0x6F, 0xF8, 0x18, 0x99, 0x4D, 0xF7, 0xC0, 0xE4, 0x37, 0x16, 0x36, 0x28, + 0x00, 0xCF, 0x2D, 0xB5, 0x85, 0x1D, 0x0C, 0x2E, 0xB7, 0xCE, 0x28, 0x6C, 0x51, 0x80, 0x81, 0x1A, + 0x32, 0x86, 0x22, 0x0F, 0x6E, 0x95, 0x02, 0x48, 0x46, 0x7E, 0xA1, 0x9C, 0x4A, 0x14, 0x78, 0x08, + 0x28, 0x58, 0x6A, 0x51, 0xB8, 0xEC, 0x10, 0x22, 0x81, 0x31, 0xD1, 0xD7, 0x80, 0xC0, 0x00, 0x50, + 0x46, 0xCC, 0xBA, 0xB2, 0x3E, 0xAD, 0x40, 0xA0, 0x24, 0xBD, 0x00, 0x15, 0xBF, 0xCF, 0x19, 0x2A, + 0x5B, 0xAD, 0x04, 0x56, 0xFF, 0xF2, 0xAB, 0xB0, 0xF9, 0x2E, 0x72, 0x42, 0xEA, 0xCF, 0xAD, 0xE4, + 0x58, 0x61, 0xC5, 0xB1, 0x80, 0x80, 0xBB, 0xF0, 0x00, 0x95, 0xC0, 0x00, 0x00, 0x00, 0x50, 0xE2, + 0xFF, 0x98, 0x1C, 0x1B, 0x19, 0x70, 0x97, 0x18, 0xBE, 0x07, 0x06, 0x07, 0xC6, 0x09, 0x02, 0x26, + 0x88, 0xE6, 0xA6, 0x8F, 0x03, 0xE6, 0x0E, 0x05, 0x86, 0x00, 0x89, 0xE6, 0x55, 0xB7, 0xFF, 0xFB, + 0x92, 0x64, 0x12, 0x07, 0xF4, 0x8E, 0x34, 0x4D, 0xC3, 0xBA, 0x7B, 0xD0, 0x2E, 0x66, 0x89, 0x25, + 0x34, 0xA6, 0xD4, 0x12, 0x94, 0xCD, 0x32, 0x0E, 0xF3, 0x47, 0x48, 0xBF, 0x9A, 0x24, 0xC0, 0xF0, + 0x1C, 0xA0, 0xE6, 0x29, 0x00, 0xA0, 0xC1, 0x3C, 0x84, 0x3E, 0x33, 0x05, 0x88, 0x01, 0x08, 0xE5, + 0x00, 0x00, 0x8D, 0x11, 0x8C, 0xCA, 0x18, 0x70, 0x50, 0x20, 0x8E, 0x29, 0xB2, 0x94, 0xFB, 0xCD, + 0x90, 0xCA, 0x54, 0x8F, 0x2C, 0xAC, 0x94, 0xF0, 0x92, 0xA8, 0x16, 0x90, 0x46, 0x82, 0x81, 0x21, + 0xC9, 0x81, 0x8C, 0x97, 0x5C, 0x0D, 0x01, 0x4A, 0x00, 0xA1, 0x2C, 0x4B, 0x98, 0x50, 0x63, 0x66, + 0xF9, 0xFD, 0x40, 0x59, 0xAF, 0x6C, 0xC5, 0xE7, 0x5A, 0x40, 0x70, 0x26, 0x6A, 0xEB, 0xFC, 0x65, + 0x53, 0x68, 0x07, 0x21, 0xF5, 0xEA, 0xC0, 0xD1, 0xFF, 0xFF, 0xFF, 0xEA, 0x79, 0x6F, 0xFF, 0xE4, + 0x52, 0x93, 0x58, 0x4A, 0xC1, 0xDA, 0x49, 0x69, 0xF3, 0x1F, 0x29, 0xE0, 0x17, 0xE2, 0xB6, 0x58, + 0x04, 0x00, 0x12, 0x48, 0xBC, 0x9F, 0xFF, 0xAA, 0xA3, 0x64, 0x93, 0xE3, 0xF0, 0x2D, 0x45, 0x17, + 0xFE, 0xD2, 0x69, 0x2B, 0xF5, 0x01, 0x32, 0x3C, 0xDF, 0xFC, 0x68, 0x15, 0x82, 0x8A, 0x62, 0xE6, + 0x32, 0x08, 0xB7, 0x2E, 0xE8, 0x6F, 0x99, 0xCC, 0xC8, 0xFF, 0xCF, 0x04, 0x36, 0x08, 0x31, 0xE4, + 0xED, 0x30, 0xCC, 0x74, 0x34, 0x5E, 0x08, 0x32, 0xD8, 0x00, 0x1A, 0x05, 0x4C, 0x3F, 0x0B, 0x4E, + 0x50, 0x6B, 0x4F, 0x02, 0x95, 0x32, 0x4A, 0x74, 0x12, 0x91, 0x3F, 0xA4, 0xF8, 0xC1, 0xA0, 0xA0, + 0x22, 0x9C, 0x48, 0xE8, 0x7D, 0x4D, 0x6A, 0xDE, 0x32, 0xF9, 0x11, 0x71, 0x9C, 0x84, 0x00, 0x18, + 0x5B, 0x48, 0xA0, 0x00, 0x64, 0x1E, 0x08, 0x22, 0x04, 0x54, 0x04, 0x5A, 0x12, 0x8B, 0x29, 0xB4, + 0x14, 0x60, 0x3C, 0x7E, 0x01, 0x67, 0xA3, 0xC8, 0xC3, 0x10, 0xBA, 0x6A, 0x2E, 0x5A, 0x98, 0x69, + 0x01, 0xE5, 0xBA, 0x33, 0x05, 0x65, 0x93, 0x6C, 0x00, 0x48, 0xC3, 0xBE, 0x96, 0xC0, 0x40, 0xA0, + 0xB7, 0x0B, 0xA6, 0x2C, 0x38, 0x30, 0x78, 0x3D, 0x9D, 0x61, 0xCF, 0xD2, 0x0D, 0xCF, 0xE5, 0x4C, + 0x84, 0xFA, 0xB9, 0x5C, 0x61, 0xB4, 0x5F, 0xFF, 0xDF, 0xFA, 0xFD, 0xEB, 0x30, 0x62, 0xDD, 0xFF, + 0xFF, 0xD2, 0x95, 0xB4, 0x0C, 0x19, 0x52, 0x56, 0xCA, 0x33, 0xC9, 0x82, 0x59, 0xB0, 0xF1, 0x8A, + 0x04, 0x9F, 0x51, 0xBD, 0x9C, 0xF4, 0x0E, 0x49, 0xBE, 0x50, 0x00, 0x06, 0x3F, 0xA8, 0xDF, 0xCA, + 0x00, 0x41, 0x00, 0x78, 0x58, 0x70, 0x58, 0xF2, 0xA1, 0x83, 0x7F, 0xFD, 0x44, 0x72, 0xE7, 0x9A, + 0x4B, 0xA3, 0x7E, 0x7E, 0x34, 0x3F, 0xEA, 0xF4, 0x71, 0x13, 0x15, 0x89, 0x6E, 0x86, 0x08, 0xE1, + 0xB2, 0x42, 0x4A, 0x9D, 0x79, 0xC1, 0x01, 0xD9, 0x82, 0xA6, 0xE0, 0x74, 0xD2, 0x09, 0x05, 0xCC, + 0x0C, 0x2C, 0x0C, 0x66, 0xC5, 0x0C, 0x01, 0x17, 0x0C, 0x10, 0x0F, 0x0C, 0x1C, 0x11, 0xCD, 0x67, + 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x87, 0x74, 0x6D, 0x33, 0xCD, 0x83, 0xBB, 0x7B, 0xD0, 0x30, 0x06, + 0x69, 0x40, 0x3C, 0x0A, 0x28, 0x11, 0xEC, 0xCD, 0x34, 0xAE, 0x77, 0x4C, 0x40, 0xC3, 0x99, 0xE4, + 0x54, 0xF0, 0x28, 0xA0, 0x1C, 0x43, 0x83, 0x13, 0x05, 0x02, 0x53, 0x13, 0x40, 0x13, 0x96, 0xC8, + 0x63, 0x0E, 0xC0, 0x33, 0x11, 0x00, 0x73, 0x06, 0x3D, 0x18, 0x30, 0x63, 0xAD, 0x70, 0x60, 0xB8, + 0x3C, 0xA5, 0x70, 0xC4, 0x87, 0x13, 0x99, 0x8D, 0xF9, 0x81, 0x08, 0x73, 0xED, 0x6A, 0x64, 0xC4, + 0x09, 0x5F, 0xF7, 0xAD, 0x73, 0x83, 0x82, 0xA0, 0x58, 0x61, 0x86, 0x07, 0x2F, 0x40, 0xF2, 0xE4, + 0xDE, 0x4D, 0xD9, 0x7B, 0xA4, 0x60, 0x04, 0x44, 0xD4, 0x13, 0xB2, 0xE2, 0xA8, 0x22, 0xB5, 0x57, + 0xC9, 0xFE, 0x49, 0x03, 0x96, 0x6A, 0x29, 0x0E, 0x5E, 0x11, 0x8D, 0x8F, 0xFF, 0xEB, 0xFB, 0xDD, + 0x0D, 0xE5, 0xAF, 0xFF, 0xF0, 0x88, 0x42, 0xFB, 0x00, 0xF7, 0x09, 0x13, 0x85, 0x5B, 0x97, 0x32, + 0x77, 0x02, 0xF0, 0xD1, 0x3E, 0x2C, 0x4C, 0x03, 0x46, 0x27, 0xE0, 0x36, 0x4B, 0xFD, 0x45, 0x3A, + 0x18, 0x46, 0x0A, 0x02, 0x78, 0x94, 0x59, 0xC2, 0x2E, 0x15, 0x8E, 0xFF, 0xF5, 0x62, 0xEA, 0x31, + 0x1A, 0x1D, 0x42, 0x66, 0xF9, 0x54, 0xC5, 0x62, 0x6F, 0xA9, 0x98, 0xC4, 0x4D, 0xC6, 0x22, 0xC3, + 0x14, 0x25, 0x0A, 0x71, 0x84, 0x09, 0x9A, 0x98, 0x46, 0x02, 0x27, 0x9A, 0x17, 0xE2, 0x6E, 0x60, + 0xA8, 0xA0, 0x68, 0xC1, 0x43, 0x73, 0xF0, 0xE7, 0x4E, 0x64, 0x24, 0x30, 0x70, 0x40, 0x94, 0x64, + 0x79, 0xA5, 0x39, 0x12, 0x08, 0x78, 0x6E, 0x63, 0x20, 0x99, 0xD3, 0x07, 0x41, 0x84, 0x81, 0x39, + 0x83, 0x60, 0x31, 0x83, 0x80, 0x28, 0x92, 0x98, 0x44, 0x10, 0xA1, 0xD0, 0xC1, 0x76, 0x17, 0xD3, + 0x19, 0x74, 0x04, 0x72, 0x07, 0x97, 0xDB, 0x9D, 0x2E, 0xBA, 0xCD, 0x8A, 0x29, 0xD1, 0x02, 0xC7, + 0x2B, 0x68, 0x62, 0x2C, 0xD5, 0xA6, 0xCB, 0x12, 0xFD, 0x39, 0x1D, 0x99, 0x72, 0xB2, 0x02, 0x9F, + 0x54, 0x69, 0x01, 0x57, 0x02, 0xE8, 0x70, 0xD3, 0x2E, 0x50, 0xBB, 0x3F, 0x96, 0x7D, 0xF6, 0x4F, + 0xCD, 0xC9, 0x19, 0x1D, 0x1F, 0x2A, 0xCA, 0xB7, 0xFF, 0xFF, 0xED, 0x96, 0xA7, 0x78, 0xE9, 0xDA, + 0xE7, 0xFF, 0xFE, 0xD4, 0x1D, 0xE4, 0x86, 0xDB, 0xAA, 0x5C, 0xD9, 0xE4, 0x5D, 0x46, 0x6E, 0x56, + 0x55, 0x04, 0xC1, 0xA2, 0x23, 0x35, 0x12, 0x20, 0x8A, 0xC6, 0xB1, 0x78, 0x16, 0x97, 0xFE, 0xC2, + 0xD6, 0x44, 0x00, 0xB1, 0x12, 0x2E, 0x16, 0x84, 0x31, 0x28, 0x8E, 0x1F, 0x3D, 0x02, 0xB8, 0xA9, + 0xFF, 0xF3, 0x52, 0xC7, 0x1B, 0x9B, 0xFA, 0x9F, 0x52, 0x1F, 0xD4, 0xDA, 0x3A, 0x3C, 0xD1, 0x12, + 0xCA, 0x78, 0x5E, 0x8B, 0x2D, 0x80, 0x00, 0x02, 0xE5, 0x4A, 0x62, 0x51, 0x0C, 0xC5, 0xA5, 0x94, + 0xC7, 0x11, 0x14, 0x00, 0x0B, 0x18, 0x32, 0x03, 0x9A, 0xBD, 0x37, 0x98, 0xFE, 0x3A, 0x82, 0x43, + 0x93, 0x04, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x8F, 0xF4, 0x4F, 0x33, 0x4D, 0xAB, 0xBA, 0x7B, 0xD4, + 0x2F, 0x06, 0x68, 0xB0, 0x24, 0x11, 0x28, 0x11, 0x80, 0xCD, 0x34, 0x0E, 0xF3, 0x46, 0xC0, 0xC3, + 0x19, 0xA2, 0xC0, 0x06, 0xA6, 0x70, 0x41, 0xD3, 0x4F, 0x4A, 0x60, 0x10, 0x8C, 0x60, 0x60, 0xD6, + 0x61, 0x28, 0xB0, 0x69, 0xEB, 0x9E, 0x61, 0x28, 0x02, 0x85, 0x83, 0x0C, 0x8D, 0x70, 0xD3, 0x0A, + 0x10, 0xBE, 0x44, 0x1F, 0x0D, 0x20, 0x78, 0x44, 0xE2, 0x99, 0x14, 0x53, 0xEC, 0xBC, 0xBC, 0xAC, + 0x1E, 0x73, 0x33, 0x16, 0x0D, 0xBD, 0xC5, 0xFB, 0x97, 0x52, 0x4D, 0xA8, 0x00, 0xD1, 0x57, 0x32, + 0xDC, 0x00, 0x3C, 0xCA, 0x11, 0x4C, 0x4A, 0xD0, 0x8C, 0xA2, 0xBB, 0xCD, 0xA3, 0xC0, 0xDA, 0xDC, + 0x46, 0x9B, 0x60, 0x9A, 0x62, 0x92, 0x8F, 0xAF, 0xF4, 0x80, 0xD7, 0xFF, 0xF2, 0x37, 0x17, 0x17, + 0x2A, 0x56, 0x7F, 0xFF, 0x0D, 0x6D, 0x0C, 0x51, 0x1F, 0x21, 0xAE, 0xF4, 0x91, 0x0B, 0x38, 0x1C, + 0xEE, 0x34, 0x33, 0xF0, 0x44, 0x7D, 0x0D, 0x68, 0x99, 0x1F, 0xFA, 0xDD, 0x4C, 0xB4, 0x05, 0x0E, + 0x01, 0xA8, 0x87, 0x06, 0x44, 0x19, 0x05, 0xA9, 0x6A, 0x38, 0x4E, 0x19, 0x13, 0x20, 0x8E, 0xAF, + 0xFF, 0xCC, 0x09, 0xC3, 0x76, 0xFE, 0x9F, 0x25, 0x43, 0x15, 0xBF, 0xFF, 0xFD, 0x27, 0x91, 0x81, + 0xB0, 0xA7, 0x28, 0x99, 0x0B, 0x02, 0x46, 0x63, 0x24, 0xA6, 0xA0, 0x82, 0x45, 0x50, 0x34, 0x0A, + 0x41, 0x19, 0x5D, 0xE0, 0x1A, 0x0C, 0x80, 0x65, 0x70, 0x01, 0x89, 0x08, 0x27, 0x3C, 0x90, 0x99, + 0x34, 0x3A, 0x1C, 0x0E, 0x31, 0x73, 0x2C, 0xF7, 0x3E, 0x03, 0x10, 0x8A, 0x4C, 0x3E, 0x15, 0x04, + 0xA4, 0x05, 0xA7, 0x03, 0x18, 0x49, 0x91, 0xCD, 0xC6, 0x3C, 0x7B, 0xBF, 0x6D, 0x39, 0xC9, 0xAF, + 0xD1, 0xCA, 0x1A, 0x20, 0xD0, 0xEC, 0x21, 0xB3, 0x28, 0x41, 0xCB, 0x94, 0xA1, 0xDC, 0x28, 0x01, + 0xA8, 0x68, 0x74, 0x30, 0x29, 0x9C, 0x22, 0xCB, 0x3B, 0x4C, 0xBC, 0x2C, 0x05, 0x9C, 0x04, 0xC0, + 0x7E, 0x28, 0xE5, 0xBC, 0xDE, 0x98, 0xC4, 0x5B, 0xEE, 0x2B, 0xF7, 0xFF, 0xF1, 0x5A, 0xB7, 0xBB, + 0x5A, 0x4B, 0x87, 0xF3, 0xFF, 0xD6, 0xCE, 0xB9, 0x9B, 0x48, 0x9D, 0xFF, 0xD7, 0x33, 0xDC, 0x66, + 0x96, 0xB5, 0x33, 0x32, 0x9F, 0xD3, 0x61, 0x52, 0xA8, 0xA7, 0x6C, 0x93, 0x01, 0xAB, 0xAC, 0x7D, + 0x0B, 0x9E, 0xA1, 0x35, 0x01, 0xD2, 0x39, 0x80, 0x09, 0x61, 0x4B, 0xDC, 0x66, 0x07, 0x2A, 0x65, + 0xE0, 0xC4, 0x37, 0x37, 0xFE, 0x81, 0x50, 0x9A, 0x03, 0x9D, 0x5F, 0x93, 0xC6, 0x11, 0xF1, 0x66, + 0x12, 0x23, 0xC5, 0x60, 0xB5, 0x89, 0xC1, 0x82, 0xCD, 0x3F, 0xFD, 0x5A, 0x58, 0x34, 0xD2, 0xC0, + 0x00, 0x00, 0x00, 0x58, 0x65, 0x2D, 0x15, 0x06, 0x0C, 0x3F, 0x4C, 0x8C, 0xD3, 0x04, 0x96, 0x59, + 0x81, 0x40, 0xE1, 0x35, 0x9E, 0x65, 0xA0, 0x40, 0x62, 0xA0, 0xD4, 0x30, 0x23, 0x19, 0x1A, 0xB2, + 0x18, 0x3C, 0x0B, 0x00, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x87, 0xF4, 0x3A, 0x33, 0x4E, 0x43, 0xBA, + 0x7B, 0xD0, 0x3E, 0x85, 0x58, 0x70, 0x02, 0x4F, 0x8A, 0x11, 0x38, 0xCD, 0x36, 0xAE, 0xE9, 0xEF, + 0x40, 0xC4, 0x95, 0x22, 0xC0, 0x26, 0xAE, 0x60, 0x42, 0x93, 0x02, 0x48, 0x43, 0xBA, 0x82, 0x73, + 0x12, 0x81, 0xE2, 0x20, 0x64, 0x14, 0xDC, 0x84, 0xB0, 0x28, 0x13, 0x4C, 0x31, 0x61, 0x8E, 0x68, + 0x15, 0x0E, 0x9D, 0x5B, 0x62, 0x46, 0xB5, 0x48, 0xDC, 0xD6, 0xF5, 0x78, 0x01, 0x0E, 0xCA, 0xE2, + 0x00, 0x78, 0x4C, 0x18, 0x7B, 0x3B, 0x76, 0x90, 0x09, 0x21, 0xB0, 0xC6, 0xD0, 0x32, 0x1E, 0x61, + 0xE2, 0x07, 0x01, 0xDC, 0x5B, 0x86, 0x7A, 0xFD, 0xE8, 0xDE, 0xDF, 0x80, 0x24, 0xA8, 0xEA, 0x3C, + 0xAF, 0xF8, 0x55, 0x7F, 0x79, 0x7F, 0x82, 0xF2, 0xBD, 0x8B, 0x19, 0xBB, 0x53, 0x46, 0xFF, 0xFF, + 0x97, 0x48, 0x1D, 0x52, 0x0C, 0xDB, 0x59, 0xA8, 0x7A, 0x59, 0xBA, 0x0C, 0x51, 0x0F, 0x9C, 0x3F, + 0x40, 0x54, 0x91, 0x53, 0x97, 0x58, 0x7D, 0x85, 0xC2, 0x8C, 0x14, 0x35, 0x08, 0x80, 0x80, 0x6A, + 0x11, 0x98, 0x36, 0x0E, 0x16, 0xF7, 0xFF, 0xC4, 0xB0, 0x1B, 0x98, 0x04, 0x68, 0x10, 0x00, 0x86, + 0x3F, 0xFF, 0x00, 0xAB, 0x0B, 0x59, 0xE5, 0x5C, 0x18, 0x22, 0x76, 0x87, 0xB6, 0x80, 0x09, 0x26, + 0xA3, 0x9C, 0x18, 0xF3, 0x3B, 0xFF, 0xFF, 0xFE, 0x52, 0x07, 0x59, 0x82, 0x98, 0x02, 0x1A, 0x19, + 0x0C, 0xE8, 0x18, 0x02, 0x00, 0x02, 0x00, 0x03, 0x07, 0x47, 0xD3, 0x16, 0x31, 0xD3, 0x0D, 0xC4, + 0xD3, 0x12, 0xC4, 0xD1, 0x10, 0x9E, 0x63, 0x3B, 0x86, 0x08, 0x02, 0x48, 0x02, 0x73, 0x15, 0x1E, + 0xE3, 0x79, 0x52, 0x73, 0x05, 0xC2, 0x83, 0x03, 0xC2, 0xF0, 0xCD, 0xE6, 0x48, 0x2A, 0x85, 0x98, + 0x30, 0x40, 0xC3, 0xA7, 0x0C, 0xA2, 0x0B, 0xB8, 0xA3, 0x80, 0x56, 0x7D, 0x87, 0xA8, 0x0C, 0x24, + 0x88, 0x1F, 0x26, 0x05, 0x4E, 0x93, 0x05, 0xA4, 0x97, 0x18, 0xC0, 0xD3, 0xD9, 0xD2, 0x94, 0x07, + 0x6F, 0x2C, 0x33, 0xD6, 0x75, 0x59, 0x7E, 0x85, 0xD5, 0x1C, 0xF3, 0x32, 0xC9, 0x35, 0x05, 0xBB, + 0x4A, 0xE7, 0x7E, 0xD4, 0x12, 0xF4, 0x7F, 0x60, 0xBF, 0xF9, 0xAF, 0xC4, 0x08, 0x5F, 0xC6, 0x52, + 0xFC, 0xC8, 0xD7, 0xA7, 0x8B, 0xCE, 0xBF, 0xFF, 0x14, 0x30, 0x98, 0x72, 0x8E, 0x3F, 0x10, 0x55, + 0xEC, 0x2A, 0x9F, 0xF4, 0x03, 0x03, 0x17, 0xFF, 0xF5, 0xAC, 0x2F, 0x23, 0x28, 0xD9, 0x7E, 0xB4, + 0x51, 0xEC, 0x99, 0x0D, 0x01, 0xDA, 0x07, 0x82, 0x9F, 0xFF, 0x19, 0x84, 0xC0, 0x06, 0x48, 0x44, + 0x8E, 0x8F, 0xE2, 0xB1, 0x44, 0x08, 0xC6, 0x1F, 0x42, 0x51, 0x91, 0x88, 0x5D, 0x60, 0xA4, 0x02, + 0x3A, 0xDE, 0x81, 0x3D, 0x78, 0x96, 0x0C, 0x44, 0x12, 0x1A, 0x33, 0x09, 0x1A, 0x94, 0x34, 0x18, + 0x0A, 0x0A, 0x98, 0x28, 0x01, 0x1D, 0x2D, 0x53, 0x1D, 0x5C, 0x14, 0x62, 0x43, 0x59, 0x89, 0x88, + 0xE7, 0x98, 0xCF, 0x19, 0x1C, 0x0C, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x04, 0x90, 0x33, 0xCC, + 0x83, 0xBC, 0xC1, 0xD2, 0x2F, 0x66, 0x28, 0xD0, 0x28, 0x0A, 0x56, 0x12, 0xB4, 0xD3, 0x2E, 0x0E, + 0xEF, 0x2B, 0x00, 0xC9, 0x18, 0x64, 0xE8, 0x06, 0x9C, 0x90, 0x16, 0x03, 0x0B, 0x36, 0x8D, 0xC7, + 0x50, 0x32, 0xF8, 0x0C, 0xC3, 0xA1, 0x33, 0x1A, 0x99, 0x86, 0x80, 0x46, 0x08, 0x03, 0x81, 0x00, + 0x66, 0x28, 0x05, 0x81, 0x90, 0x05, 0xD9, 0x52, 0xA0, 0x60, 0x19, 0x44, 0xEA, 0x4B, 0x18, 0x02, + 0x2E, 0x26, 0xCD, 0x0F, 0x85, 0xD6, 0xE2, 0xE9, 0x5C, 0x03, 0xD4, 0xD0, 0x37, 0x32, 0x0A, 0x2B, + 0x56, 0x9C, 0x74, 0x47, 0xB1, 0x8B, 0x4E, 0x48, 0x73, 0x1C, 0x14, 0xBE, 0x82, 0xE4, 0xB3, 0x3C, + 0xDF, 0x98, 0x3F, 0x51, 0xE1, 0x83, 0xAA, 0xEA, 0x19, 0xBF, 0xFF, 0xB9, 0x6B, 0xF3, 0xC6, 0x5B, + 0xFF, 0xF2, 0xEB, 0xFB, 0xA5, 0x97, 0x6A, 0xD4, 0x19, 0x6F, 0xFF, 0xE8, 0x79, 0xA7, 0xDE, 0x82, + 0xBB, 0xE8, 0x87, 0x6B, 0xDB, 0xBE, 0xC5, 0x2F, 0xD3, 0x8B, 0xFE, 0x46, 0x70, 0x48, 0x10, 0xA3, + 0x6C, 0x1C, 0x2F, 0xFF, 0xF2, 0xA0, 0x28, 0xF0, 0xB9, 0x6F, 0xFE, 0x44, 0x12, 0x46, 0xAE, 0xDA, + 0x14, 0x2D, 0x24, 0x09, 0xA1, 0xCC, 0x60, 0x04, 0x88, 0x23, 0x8C, 0x8B, 0x0C, 0x45, 0x9F, 0x9E, + 0x3C, 0x60, 0x98, 0x68, 0x22, 0x06, 0x83, 0x4A, 0x3D, 0x08, 0xFA, 0x34, 0x09, 0x18, 0x34, 0x23, + 0x98, 0xCE, 0xCA, 0x9C, 0x04, 0x3D, 0x8B, 0x08, 0xC6, 0x1B, 0x19, 0x47, 0x90, 0xDE, 0xC6, 0xAD, + 0x10, 0x46, 0x00, 0x8A, 0x46, 0x00, 0x83, 0x47, 0x29, 0xBA, 0x66, 0xF8, 0x34, 0x2A, 0x7A, 0x73, + 0xC6, 0x87, 0x51, 0x66, 0x3A, 0x00, 0x63, 0xEB, 0x00, 0xD2, 0x21, 0xED, 0xC7, 0x3E, 0x10, 0xDD, + 0x81, 0xE1, 0x89, 0xCC, 0x15, 0x11, 0x25, 0x0A, 0x1E, 0x00, 0x93, 0x20, 0x88, 0x75, 0x51, 0x2C, + 0x9F, 0x76, 0xAA, 0x0C, 0x31, 0x11, 0x1B, 0x23, 0xB6, 0x1D, 0xCA, 0x50, 0x57, 0x97, 0x89, 0x05, + 0x4B, 0x3C, 0xE8, 0x32, 0x39, 0x5B, 0xC8, 0x04, 0x94, 0x35, 0x97, 0x5D, 0x09, 0x43, 0x23, 0xA2, + 0x45, 0x25, 0xE1, 0x90, 0x21, 0x57, 0xB2, 0x19, 0x31, 0xA7, 0x63, 0x07, 0x65, 0xFE, 0xD1, 0x2B, + 0xE7, 0xBA, 0xCD, 0xB7, 0x7F, 0x52, 0x1E, 0xD7, 0x9E, 0x7C, 0xB2, 0xEE, 0x54, 0xDD, 0xFF, 0x7C, + 0x6C, 0xFA, 0xF9, 0xA5, 0xD5, 0x2C, 0x4D, 0xF2, 0xCA, 0x58, 0xFD, 0xF2, 0x26, 0x9D, 0x1C, 0x01, + 0x0C, 0x42, 0x00, 0xC0, 0x40, 0x0B, 0xCF, 0x84, 0x3A, 0x4D, 0xFE, 0xC7, 0xF8, 0xE1, 0x13, 0x3A, + 0x69, 0x50, 0x7E, 0x4D, 0x0C, 0x8E, 0xCC, 0x65, 0x7A, 0x31, 0xFA, 0x9C, 0xD3, 0x11, 0x7E, 0x17, + 0x33, 0x2A, 0x2D, 0xCA, 0x0E, 0xB2, 0x8E, 0x87, 0xFF, 0x2A, 0x6C, 0x74, 0x46, 0x63, 0x00, 0x8B, + 0xA5, 0x15, 0x49, 0xD4, 0x42, 0x11, 0x82, 0x99, 0x82, 0xA9, 0x70, 0x83, 0x00, 0x2C, 0xC0, 0x10, + 0x09, 0x0C, 0x03, 0x01, 0x04, 0xC2, 0xB9, 0x0B, 0xFF, 0xFB, 0x92, 0x64, 0x0B, 0x0E, 0x54, 0x4F, + 0x34, 0xCC, 0x83, 0xDA, 0x6A, 0xF0, 0x35, 0x46, 0x49, 0x31, 0x29, 0x63, 0xB4, 0x11, 0x24, 0xD3, + 0x30, 0x4E, 0xE9, 0xEB, 0x80, 0xCB, 0x14, 0x65, 0x54, 0x75, 0x8A, 0x28, 0x4C, 0x06, 0x01, 0x44, + 0xC0, 0x80, 0x01, 0x8C, 0x06, 0x42, 0x04, 0xC6, 0xC0, 0x4D, 0x81, 0xE0, 0x0C, 0x11, 0x93, 0xA9, + 0x54, 0xFD, 0x81, 0x03, 0x1A, 0x32, 0x28, 0x48, 0x42, 0x98, 0x92, 0xE1, 0x70, 0x92, 0xF1, 0xC1, + 0x83, 0x6C, 0x61, 0xC5, 0x00, 0x10, 0x84, 0x6C, 0x2D, 0xDE, 0x1C, 0x30, 0xE1, 0x06, 0x8A, 0xB2, + 0xF8, 0x50, 0x24, 0xFA, 0xC5, 0x72, 0x52, 0x8C, 0x0D, 0x7E, 0x02, 0x81, 0x0B, 0xF8, 0xA8, 0x71, + 0xBF, 0x06, 0x2B, 0xF6, 0xA7, 0x7C, 0x42, 0x04, 0x78, 0xC6, 0x4E, 0x63, 0x5B, 0x4F, 0x11, 0xA5, + 0x34, 0x8D, 0x6C, 0x04, 0x28, 0xF7, 0x51, 0xFE, 0x3B, 0x89, 0xA9, 0x56, 0x86, 0xA3, 0x77, 0x58, + 0xE0, 0x1E, 0x0F, 0xF9, 0x74, 0xF4, 0xE1, 0xFC, 0xBC, 0x6B, 0x24, 0x87, 0xC6, 0x24, 0x58, 0xA1, + 0x00, 0x15, 0x0B, 0xF2, 0x7F, 0x35, 0x82, 0xA8, 0x11, 0x2F, 0xFC, 0x4B, 0x1D, 0xE8, 0x83, 0xC3, + 0xD5, 0xEB, 0xD4, 0x00, 0xC0, 0x28, 0x37, 0x8E, 0xE9, 0xF6, 0x9B, 0xF2, 0x5B, 0xA8, 0x64, 0xCD, + 0x53, 0xE7, 0xFE, 0xCA, 0x0E, 0x5F, 0xFD, 0x22, 0xE9, 0x7C, 0x84, 0x8B, 0x3F, 0xFF, 0xB3, 0xA0, + 0x2B, 0x05, 0x40, 0x40, 0x15, 0x48, 0x0D, 0x85, 0x15, 0x4C, 0x31, 0x23, 0xCC, 0xCE, 0x7E, 0x4D, + 0x81, 0x11, 0x48, 0x86, 0x53, 0x22, 0xC3, 0xF3, 0x65, 0xA5, 0x00, 0x76, 0xBE, 0x62, 0x79, 0x32, + 0x61, 0xC0, 0xCE, 0x65, 0xB9, 0xB6, 0x01, 0x3E, 0x6C, 0x8C, 0x1D, 0x8C, 0x47, 0x82, 0x61, 0x00, + 0x83, 0x82, 0x34, 0x18, 0x8C, 0xF5, 0x96, 0x5D, 0x6B, 0x94, 0xBE, 0xC7, 0x0D, 0x9A, 0x71, 0x3B, + 0xCC, 0xC8, 0x1C, 0xC1, 0x1F, 0xA8, 0x42, 0xC6, 0xC2, 0x34, 0x48, 0x1A, 0x18, 0x28, 0x40, 0x70, + 0xB8, 0xE1, 0x08, 0xB3, 0x30, 0x9C, 0xDA, 0x9B, 0x52, 0xC4, 0xEB, 0x5C, 0x74, 0x9C, 0x7C, 0x5F, + 0xCE, 0x26, 0xB2, 0x5A, 0x03, 0xBB, 0xC5, 0x52, 0x2C, 0x01, 0x6A, 0x7D, 0x1E, 0xE5, 0x6D, 0xE0, + 0xA8, 0x3F, 0x21, 0xCB, 0xFF, 0xDA, 0x95, 0x63, 0xDF, 0x19, 0xDE, 0x71, 0xBC, 0x3E, 0xAE, 0xFF, + 0xFF, 0xF9, 0x35, 0xEB, 0x02, 0x06, 0x9C, 0x1C, 0x2D, 0x29, 0x9C, 0xB3, 0xB8, 0x31, 0x54, 0x00, + 0x3F, 0x09, 0x01, 0xBE, 0xAC, 0x69, 0xBF, 0xF5, 0x14, 0x19, 0xC9, 0xF6, 0x1A, 0x16, 0x93, 0xAC, + 0xAD, 0x7F, 0xFD, 0x40, 0x75, 0x64, 0xC3, 0x65, 0xFC, 0xB5, 0x12, 0x59, 0xA1, 0xB5, 0x28, 0x23, + 0xD6, 0xF7, 0x1A, 0xF9, 0x06, 0x4A, 0x7C, 0x33, 0xE8, 0xFF, 0xF7, 0x0B, 0xA7, 0x43, 0x2A, 0x3E, + 0x18, 0x04, 0x12, 0xF8, 0x1C, 0x06, 0xAD, 0x03, 0x39, 0x8B, 0x00, 0x17, 0x34, 0x20, 0x0D, 0x4C, + 0x2E, 0x1F, 0x0D, 0x71, 0xA4, 0x0C, 0xD5, 0x0C, 0xCC, 0x3C, 0xFF, 0xFB, 0x92, 0x64, 0x0C, 0x86, + 0xD4, 0x4B, 0x33, 0xCC, 0x0B, 0xBA, 0x5B, 0x70, 0x31, 0xC6, 0x79, 0x10, 0x15, 0x62, 0x8A, 0x10, + 0xE8, 0xCD, 0x32, 0xAE, 0xEB, 0x26, 0xC0, 0xC2, 0x98, 0x64, 0x04, 0xF0, 0x1C, 0x32, 0x0C, 0x93, + 0x68, 0xC9, 0x43, 0x84, 0x42, 0x00, 0x18, 0x26, 0x0B, 0x19, 0xCE, 0x46, 0x80, 0x17, 0x97, 0x8D, + 0x14, 0xD2, 0x34, 0xEC, 0x00, 0x2E, 0xA8, 0x88, 0x90, 0x59, 0xD8, 0x0C, 0xD9, 0x12, 0x38, 0x84, + 0x70, 0x74, 0x01, 0x10, 0x18, 0xDD, 0x20, 0xC1, 0xF5, 0x32, 0x81, 0x93, 0x4C, 0xC0, 0x22, 0x45, + 0x28, 0xB9, 0x69, 0x4C, 0x34, 0x46, 0x96, 0xD5, 0x13, 0x3A, 0x41, 0x66, 0xCB, 0x77, 0xA2, 0x95, + 0xBF, 0xC8, 0x5D, 0xAB, 0x31, 0x59, 0x00, 0x71, 0xF6, 0xE6, 0xE7, 0xFF, 0xEA, 0x58, 0xD3, 0xA4, + 0x55, 0x39, 0x9F, 0xA2, 0x02, 0x20, 0xDA, 0xA4, 0x01, 0x34, 0xBF, 0xFF, 0xCA, 0x2F, 0xCA, 0xCA, + 0xCD, 0xC4, 0x1A, 0xA8, 0x8E, 0x4D, 0xC8, 0x01, 0xA0, 0x1D, 0xBB, 0x68, 0xDE, 0x65, 0x60, 0x81, + 0xC1, 0x6F, 0xE6, 0xFF, 0x5A, 0x3A, 0x41, 0x26, 0xC1, 0x1C, 0x54, 0x43, 0xD0, 0x10, 0x97, 0x7F, + 0xFA, 0x26, 0xB0, 0xEF, 0x95, 0x0F, 0x30, 0xC0, 0x8F, 0x4F, 0x5D, 0x65, 0x01, 0xAA, 0x8E, 0xDA, + 0x8D, 0x41, 0x29, 0x6F, 0xFF, 0xE6, 0xF5, 0x11, 0xF0, 0xE2, 0xE1, 0x06, 0x84, 0x01, 0x40, 0xC3, + 0x40, 0x06, 0x74, 0xB0, 0x26, 0x06, 0x00, 0x86, 0x3B, 0x4D, 0x86, 0x83, 0x87, 0x80, 0x50, 0x54, + 0xC2, 0x20, 0x8C, 0xC6, 0xF5, 0xEC, 0x40, 0x84, 0xF7, 0x2F, 0x31, 0xA5, 0x8C, 0x6A, 0xC3, 0xA2, + 0x84, 0x11, 0x88, 0xFF, 0xD8, 0x3A, 0x2E, 0x82, 0x82, 0xD8, 0x99, 0xB6, 0xE0, 0x50, 0xF5, 0xC8, + 0x86, 0x86, 0x7E, 0xA6, 0x7B, 0x88, 0xC7, 0x2A, 0x68, 0xC3, 0x06, 0xDD, 0xBA, 0xED, 0xB8, 0x69, + 0xE5, 0x0F, 0x16, 0x50, 0xC9, 0x35, 0x18, 0xDD, 0xE4, 0xFE, 0x11, 0x12, 0xB8, 0x3D, 0xD0, 0x83, + 0xB6, 0xD2, 0xDA, 0x64, 0x13, 0x0E, 0x46, 0xD2, 0x4A, 0x2B, 0x55, 0xBA, 0x25, 0xA9, 0x41, 0xAE, + 0xC4, 0x5B, 0xB9, 0xF6, 0x1A, 0x6A, 0x74, 0x30, 0x14, 0x56, 0xD7, 0xEF, 0xB0, 0x0C, 0xBB, 0x6F, + 0x25, 0x5B, 0x5F, 0x9F, 0x7F, 0x3F, 0x98, 0xFF, 0xFA, 0x1A, 0xD5, 0xE6, 0xAF, 0xC6, 0xEA, 0x51, + 0xC9, 0x26, 0x6E, 0x7F, 0x29, 0xE5, 0xB4, 0x48, 0x23, 0x70, 0xE5, 0x40, 0x7B, 0xD0, 0x17, 0x0C, + 0xA0, 0x58, 0x1D, 0x8F, 0x00, 0xE7, 0xFF, 0xF3, 0x67, 0x12, 0x42, 0x4E, 0x54, 0x49, 0x35, 0xC1, + 0xEB, 0x50, 0x24, 0x1A, 0x75, 0x2C, 0x3E, 0xDD, 0x06, 0xEF, 0x5F, 0xFA, 0xBB, 0x26, 0x81, 0x00, + 0xCC, 0x98, 0xC1, 0x68, 0x70, 0x31, 0xFF, 0xEA, 0x00, 0x00, 0x05, 0x01, 0xF5, 0x55, 0x61, 0xD0, + 0x41, 0xBB, 0x74, 0x46, 0x84, 0x19, 0x08, 0xC0, 0x26, 0x15, 0x08, 0x1A, 0x88, 0x26, 0x70, 0x58, + 0x83, 0xAD, 0x19, 0xA3, 0x86, 0x3A, 0x21, 0x81, 0x16, 0x68, 0xCC, 0x9D, 0xFF, 0xFB, 0x90, 0x64, + 0x12, 0x0F, 0xC4, 0x2F, 0x34, 0x4D, 0x1B, 0x9A, 0x79, 0xF0, 0x31, 0xA8, 0xC9, 0x4D, 0x24, 0x0A, + 0x0C, 0x0F, 0xE4, 0xD1, 0x32, 0x0E, 0x65, 0x2D, 0xC0, 0xC7, 0x1A, 0x63, 0x80, 0x90, 0x28, 0x30, + 0x51, 0xA7, 0x48, 0xB8, 0x09, 0x49, 0x0B, 0x31, 0x02, 0x45, 0x32, 0x86, 0xC0, 0x20, 0x02, 0xC4, + 0xC0, 0x51, 0x1C, 0x0C, 0x5B, 0xA6, 0x4E, 0xD6, 0x96, 0x22, 0x24, 0xAF, 0xE8, 0x38, 0x04, 0x08, + 0x98, 0x9C, 0x94, 0x7F, 0x04, 0x8C, 0x4C, 0xD2, 0xB1, 0x0B, 0x55, 0x96, 0x43, 0xD4, 0xFF, 0x4F, + 0x42, 0x53, 0x85, 0x6B, 0x8B, 0x71, 0x84, 0xFD, 0x88, 0xC1, 0x40, 0x65, 0xBE, 0xEC, 0xC9, 0x13, + 0xC0, 0xFF, 0x43, 0xBF, 0xF8, 0xC4, 0xDE, 0xD1, 0xF1, 0xE0, 0xCF, 0x02, 0x5D, 0x42, 0xFF, 0xE6, + 0x33, 0xD7, 0xED, 0xAA, 0x48, 0x6F, 0xA7, 0x48, 0xC0, 0xA6, 0x18, 0x5A, 0x9C, 0x63, 0xDF, 0xFD, + 0x7F, 0xD2, 0x00, 0x00, 0x00, 0x20, 0x03, 0x00, 0x0B, 0x00, 0x04, 0x7E, 0x1F, 0x17, 0xE6, 0xE6, + 0x3F, 0xCC, 0x73, 0x0C, 0xDF, 0xFF, 0x4A, 0xD0, 0xC8, 0x8A, 0x5F, 0x0C, 0x8F, 0x7F, 0x35, 0xCF, + 0x7F, 0xFC, 0x63, 0x4E, 0x79, 0x7A, 0x12, 0x7B, 0x55, 0xBF, 0xFF, 0xCC, 0x7C, 0x85, 0x4E, 0x90, + 0x1F, 0xFB, 0xA1, 0x77, 0x55, 0x23, 0x80, 0xA3, 0xB3, 0x09, 0x35, 0x0D, 0xDC, 0x2D, 0x07, 0x07, + 0xCC, 0xAC, 0x16, 0x33, 0xD7, 0x30, 0x04, 0xB5, 0x32, 0x81, 0x5C, 0x2A, 0x27, 0x0A, 0x25, 0x4C, + 0x9E, 0x3C, 0x31, 0x40, 0x88, 0x04, 0x70, 0x27, 0x9C, 0x04, 0xAA, 0xA6, 0x30, 0x4B, 0x66, 0x31, + 0xF4, 0x20, 0x11, 0x88, 0x7D, 0x06, 0xD2, 0x22, 0x91, 0x69, 0x0B, 0x3B, 0x9C, 0x41, 0x12, 0x1C, + 0x97, 0x5C, 0x69, 0xE7, 0x52, 0xBA, 0x12, 0xF1, 0x22, 0x5B, 0x37, 0x90, 0xE4, 0xA1, 0xF2, 0x88, + 0x26, 0x4B, 0x0C, 0xC0, 0x32, 0x94, 0x9F, 0x46, 0x9B, 0x7C, 0x94, 0xC1, 0xF0, 0x96, 0x47, 0x28, + 0xA1, 0xA1, 0x7F, 0x9E, 0x98, 0xB2, 0x33, 0x2B, 0xE7, 0x67, 0x9F, 0xF5, 0xA7, 0xFC, 0xBF, 0xC8, + 0x1A, 0x51, 0xDB, 0x9F, 0xF4, 0x0A, 0x92, 0x2C, 0x58, 0x02, 0x68, 0xDA, 0x12, 0x82, 0xD1, 0xE4, + 0xE6, 0x62, 0xD8, 0x6D, 0x8A, 0x0A, 0xC3, 0xEF, 0xD1, 0xF6, 0xA0, 0x30, 0x1A, 0x05, 0x40, 0x14, + 0x24, 0x82, 0xCF, 0xFD, 0xFD, 0xC4, 0x85, 0x11, 0xDB, 0x9A, 0x2D, 0x08, 0x41, 0x4F, 0x8C, 0x8B, + 0x8F, 0x0B, 0xFF, 0xD2, 0xA5, 0x03, 0x6C, 0x16, 0x07, 0x62, 0x40, 0x8B, 0xAB, 0x1E, 0x4E, 0x78, + 0x83, 0x27, 0xFF, 0xF2, 0x2A, 0x80, 0x00, 0x05, 0xA5, 0xE0, 0x60, 0x22, 0xD9, 0x96, 0xE9, 0xE6, + 0x5F, 0x10, 0xA4, 0xD1, 0x8F, 0x96, 0x46, 0x4B, 0x40, 0x9C, 0x85, 0x66, 0xF7, 0xA1, 0xBF, 0x58, + 0x65, 0x61, 0x19, 0x56, 0xA6, 0x1C, 0xA1, 0xA5, 0x0C, 0x71, 0x02, 0x98, 0xC0, 0x82, 0xC0, 0x0C, + 0x40, 0x30, 0x51, 0x4B, 0x88, 0xDA, 0xDE, 0x82, 0x87, 0xB6, 0x47, 0xC8, 0x3E, 0xFF, 0xFB, 0x92, + 0x64, 0x1C, 0x0F, 0x73, 0xDF, 0x34, 0x4D, 0x2B, 0x9A, 0x79, 0xD0, 0x31, 0x26, 0x79, 0x00, 0x04, + 0x08, 0x0C, 0x4F, 0x68, 0xCD, 0x34, 0x0E, 0xE5, 0xE9, 0x18, 0xC0, 0x9A, 0x25, 0x14, 0x23, 0x15, + 0xF0, 0xD5, 0x6C, 0x87, 0xA0, 0xB5, 0x15, 0x6C, 0xEF, 0xCB, 0x81, 0x2F, 0x38, 0x94, 0x82, 0xD0, + 0x9B, 0xFC, 0x4E, 0x17, 0x07, 0x6A, 0x90, 0xA0, 0x3F, 0x32, 0x9A, 0x09, 0xCB, 0x6D, 0x16, 0xC5, + 0x01, 0x5A, 0xF9, 0x3C, 0xB8, 0x63, 0x39, 0xD6, 0x54, 0x4F, 0x47, 0x76, 0x75, 0xFF, 0x9F, 0x5F, + 0xFF, 0x8D, 0xD2, 0x06, 0xF3, 0xE2, 0xFC, 0x44, 0x56, 0x47, 0x67, 0xBC, 0x19, 0xA2, 0xB2, 0xB8, + 0xC5, 0xFD, 0xB7, 0x7B, 0x80, 0x10, 0xE5, 0x9E, 0x2F, 0xFF, 0xA5, 0x71, 0x8B, 0xB9, 0xE5, 0x16, + 0x18, 0x02, 0x62, 0x68, 0x3E, 0xC5, 0xF2, 0xC4, 0x79, 0x72, 0xC5, 0xC6, 0x26, 0xF6, 0xA9, 0x01, + 0xC9, 0xD4, 0xE9, 0x23, 0x0E, 0x1F, 0xF3, 0xAD, 0xED, 0xFF, 0x1F, 0xFF, 0x16, 0xE3, 0x05, 0x0E, + 0x6D, 0x9B, 0xCA, 0x36, 0x06, 0x10, 0x8A, 0xAE, 0xF4, 0x72, 0x31, 0x52, 0x10, 0x28, 0x1E, 0xCC, + 0x0D, 0x06, 0x81, 0x24, 0x91, 0x90, 0xE4, 0xC8, 0x88, 0x23, 0x31, 0x58, 0x53, 0x05, 0x2A, 0x64, + 0x42, 0x6A, 0x1A, 0x6A, 0xB6, 0x74, 0x52, 0x73, 0xB6, 0x20, 0x10, 0xC5, 0x19, 0x32, 0x91, 0xC6, + 0xFB, 0x28, 0x55, 0x31, 0xFC, 0x9B, 0x2B, 0x3B, 0x11, 0x58, 0xCC, 0xC3, 0xAD, 0x0F, 0x37, 0x46, + 0xF1, 0xB0, 0x2E, 0x4C, 0x2E, 0x42, 0x3E, 0x13, 0x0E, 0x56, 0xA1, 0x3B, 0x7C, 0x68, 0x37, 0x12, + 0xB6, 0xF7, 0xAE, 0x64, 0x7B, 0xC5, 0xDB, 0xB5, 0x5B, 0xF8, 0xAE, 0x70, 0x4F, 0x60, 0x4E, 0x0B, + 0x81, 0x24, 0x3F, 0x4B, 0xD9, 0x0A, 0x8F, 0xFF, 0xAD, 0x3B, 0x5E, 0x3F, 0xC3, 0x9E, 0x2A, 0xC9, + 0x98, 0x0E, 0x7F, 0x09, 0xF6, 0xD8, 0xD2, 0xB6, 0xA3, 0x5B, 0x56, 0x95, 0x33, 0x6B, 0xC9, 0xB8, + 0xE9, 0xC4, 0x60, 0xE2, 0xFD, 0x24, 0xBF, 0xFC, 0x5A, 0xC3, 0xF3, 0xD3, 0xDD, 0x2B, 0x20, 0xC7, + 0x21, 0xA6, 0x10, 0x5F, 0xEF, 0xF2, 0xDA, 0x0B, 0xEE, 0x21, 0x01, 0xD0, 0x5D, 0x8B, 0xA7, 0xBF, + 0x52, 0x16, 0x16, 0x2C, 0x1E, 0xEB, 0xC6, 0x8A, 0xB7, 0xFF, 0xC8, 0x48, 0x41, 0x48, 0x4F, 0xD6, + 0x82, 0xB5, 0x7F, 0x04, 0x21, 0xE6, 0x58, 0xA8, 0x67, 0xEE, 0x24, 0x02, 0xC1, 0x41, 0xD3, 0xC3, + 0xDE, 0x35, 0xF7, 0xC3, 0x52, 0x3B, 0x37, 0xB3, 0x29, 0xB0, 0x49, 0x21, 0x30, 0x31, 0x83, 0x8B, + 0x19, 0x51, 0x81, 0xA9, 0x41, 0x19, 0x58, 0x78, 0x70, 0x79, 0xD3, 0x44, 0x41, 0x79, 0x1A, 0x78, + 0x8F, 0x66, 0x79, 0x17, 0x2D, 0x4C, 0x22, 0xD7, 0x58, 0xCC, 0x02, 0xBE, 0x1A, 0x22, 0x73, 0xA9, + 0xD3, 0x2D, 0x79, 0x2B, 0x90, 0x3D, 0x5E, 0xD8, 0xA0, 0x5D, 0x6B, 0xB1, 0x93, 0x34, 0xB9, 0xB6, + 0x9E, 0xAA, 0x71, 0xF6, 0x90, 0x44, 0xA6, 0x9B, 0x15, 0x6B, 0xEC, 0x7A, 0x1D, 0x82, 0xA8, 0xFF, + 0xFB, 0x92, 0x64, 0x2E, 0x8F, 0x34, 0x15, 0x33, 0xCB, 0x83, 0x78, 0x4B, 0xE2, 0x2F, 0xC5, 0xC9, + 0x75, 0x14, 0xC2, 0x96, 0x90, 0x20, 0xD1, 0x2E, 0x0E, 0x69, 0x2D, 0x80, 0xBF, 0x8E, 0x25, 0xE0, + 0x63, 0x98, 0x38, 0xF6, 0xC2, 0x15, 0xF2, 0xEE, 0x52, 0xA6, 0x70, 0xD4, 0xBE, 0x2D, 0xBF, 0xF8, + 0xE9, 0x5C, 0xCD, 0xA6, 0xAC, 0x06, 0x14, 0xDA, 0xC8, 0x27, 0x40, 0xBA, 0x52, 0x1B, 0x28, 0x84, + 0x54, 0x2E, 0x16, 0x8E, 0x76, 0x89, 0x49, 0x2C, 0x78, 0x80, 0x00, 0x01, 0x06, 0x86, 0xFA, 0x44, + 0xC2, 0x3F, 0xE5, 0x61, 0x68, 0x59, 0xA6, 0x51, 0x86, 0x1E, 0x04, 0x72, 0x06, 0x9E, 0x99, 0x87, + 0x92, 0x35, 0x22, 0xA8, 0xD7, 0x46, 0xE1, 0x2F, 0x08, 0x52, 0x9C, 0x4A, 0x5C, 0x59, 0xA0, 0x19, + 0x7C, 0xCD, 0xFF, 0xF5, 0x45, 0xA0, 0xE2, 0xBD, 0x50, 0xE2, 0x52, 0x98, 0xD9, 0xB8, 0x36, 0xD3, + 0x30, 0x60, 0x54, 0xC4, 0x07, 0x70, 0x13, 0x24, 0xCC, 0x6F, 0x21, 0xE4, 0xE0, 0x63, 0xE0, 0x10, + 0x2A, 0x31, 0xE8, 0x60, 0xC6, 0xC6, 0x23, 0x01, 0x20, 0x0C, 0x1E, 0x21, 0x31, 0xC0, 0x05, 0x84, + 0x94, 0x8E, 0x34, 0x27, 0xC0, 0x00, 0x97, 0x81, 0x72, 0x44, 0x05, 0xC3, 0x98, 0xA0, 0x05, 0x35, + 0xD2, 0x01, 0x74, 0x3C, 0x2E, 0x5A, 0xE4, 0x22, 0x30, 0x9C, 0x8A, 0x14, 0x5E, 0x05, 0x31, 0x53, + 0x84, 0x8C, 0x88, 0x4E, 0x3D, 0x0C, 0xC9, 0xDA, 0x87, 0x9B, 0x04, 0x13, 0x29, 0x87, 0x9D, 0xB8, + 0x21, 0x6E, 0x93, 0x01, 0x7E, 0x97, 0xE3, 0x88, 0xA1, 0x33, 0xF9, 0xA4, 0x60, 0xA1, 0x40, 0x64, + 0x01, 0x99, 0x7D, 0xFA, 0xCF, 0x5A, 0xDA, 0xF0, 0x69, 0x66, 0x72, 0x74, 0xE8, 0x7E, 0x54, 0x94, + 0x58, 0xAB, 0xA1, 0x76, 0xAC, 0x92, 0xE9, 0xC3, 0xF4, 0x0C, 0x41, 0x00, 0x26, 0x0E, 0x13, 0x7A, + 0xC0, 0xF1, 0x3B, 0xB7, 0xE8, 0x8C, 0x08, 0x25, 0x0E, 0x51, 0x33, 0x1A, 0x48, 0xF2, 0xEC, 0x3A, + 0x40, 0x40, 0x92, 0x56, 0xF8, 0x69, 0x4E, 0x6B, 0x40, 0xEB, 0x9E, 0xA6, 0x06, 0xE1, 0x60, 0xF8, + 0x71, 0xF7, 0xAE, 0xF9, 0x8B, 0x99, 0x0A, 0x2B, 0x72, 0x15, 0x6E, 0xE2, 0x82, 0x63, 0x15, 0x47, + 0x8C, 0x70, 0x9A, 0x30, 0x00, 0x38, 0x51, 0x3A, 0x64, 0x42, 0x11, 0x98, 0x4B, 0xE6, 0x9C, 0x18, + 0x19, 0xF4, 0x44, 0x61, 0x71, 0x31, 0x8B, 0x89, 0x26, 0x76, 0x01, 0x8B, 0x34, 0x7D, 0x08, 0x1C, + 0x27, 0x22, 0xC8, 0x8C, 0x99, 0xD1, 0x26, 0x2C, 0xD1, 0xC8, 0x11, 0x03, 0x2E, 0x92, 0x12, 0x04, + 0x82, 0x8F, 0x17, 0x48, 0x77, 0x86, 0x91, 0xAB, 0x90, 0x80, 0x5A, 0x33, 0x6D, 0x28, 0xBD, 0x6A, + 0xAF, 0x0B, 0x20, 0x10, 0xA2, 0x8E, 0xA3, 0x64, 0x6B, 0xBD, 0x87, 0x18, 0x2C, 0x95, 0x96, 0xC1, + 0xCC, 0x11, 0xC4, 0x05, 0x0B, 0x89, 0x71, 0x9B, 0xB9, 0x31, 0xC1, 0x25, 0x05, 0x15, 0x13, 0x2B, + 0x64, 0x2F, 0x2E, 0xFE, 0x93, 0x3D, 0x22, 0x3C, 0xAD, 0xB5, 0x23, 0x4D, 0x31, 0xF2, 0xBF, 0xC8, + 0xC0, 0xFF, 0xFB, 0x92, 0x64, 0x3B, 0x8F, 0xC3, 0xF1, 0x33, 0x4B, 0x83, 0x9A, 0x4A, 0xF2, 0x33, + 0x23, 0x69, 0x50, 0x25, 0x66, 0x40, 0x11, 0x10, 0xCD, 0x2A, 0x0E, 0x69, 0x8D, 0x88, 0xD1, 0x8D, + 0x25, 0xC8, 0xC3, 0x98, 0x88, 0xBE, 0x2D, 0x16, 0x6B, 0x7D, 0x5B, 0xE1, 0xB4, 0x36, 0x39, 0x90, + 0x41, 0x0B, 0xC1, 0x90, 0xCA, 0x22, 0x22, 0x22, 0x3B, 0x2C, 0x00, 0x7C, 0xEE, 0x01, 0x56, 0x29, + 0x81, 0x14, 0x4C, 0x13, 0x80, 0x18, 0x59, 0x9B, 0x6D, 0x37, 0xF4, 0xC3, 0x50, 0x0C, 0x14, 0x3E, + 0x8F, 0x1C, 0x97, 0x1E, 0x1A, 0xDC, 0x24, 0x09, 0x3D, 0x8F, 0xEA, 0x06, 0x91, 0xA1, 0x44, 0xD6, + 0xC8, 0xC1, 0x28, 0xCE, 0x62, 0x53, 0x85, 0xC0, 0x44, 0xA1, 0x46, 0x08, 0x42, 0x19, 0x4A, 0x24, + 0x63, 0x15, 0x59, 0x95, 0xC8, 0xA6, 0x51, 0x0F, 0x18, 0x44, 0x66, 0x62, 0x81, 0x31, 0x8A, 0x51, + 0x22, 0x4B, 0x83, 0x1B, 0x84, 0x8D, 0x5D, 0x00, 0x35, 0x03, 0x82, 0xD4, 0xD8, 0x02, 0x38, 0x27, + 0xD6, 0x00, 0x2E, 0x34, 0x0C, 0xF8, 0x39, 0x99, 0x7B, 0xEE, 0x16, 0xA5, 0x83, 0x4A, 0x98, 0xE1, + 0x00, 0x40, 0x30, 0xA5, 0x30, 0xC8, 0xBF, 0x25, 0xC5, 0x60, 0x85, 0x43, 0x81, 0x0D, 0xDA, 0xB5, + 0x34, 0x6A, 0xDA, 0x0D, 0x33, 0x4B, 0xAF, 0xAC, 0xB5, 0x30, 0x44, 0x67, 0x40, 0x55, 0xA3, 0x2F, + 0x0C, 0x99, 0x93, 0xBD, 0xE0, 0x6F, 0x0C, 0xCF, 0x43, 0xB3, 0x55, 0x67, 0x03, 0x36, 0x50, 0x65, + 0x08, 0x33, 0x98, 0x17, 0x4C, 0xCE, 0xF7, 0xC0, 0x60, 0xCD, 0x66, 0x0F, 0x80, 0xBC, 0x7D, 0x7B, + 0xAF, 0xF6, 0x32, 0xCE, 0xC4, 0xBD, 0x9E, 0xC0, 0x02, 0x1C, 0x13, 0x88, 0xEA, 0x26, 0x00, 0x90, + 0x3B, 0x68, 0x4C, 0x20, 0x0C, 0x99, 0x20, 0x81, 0x74, 0x20, 0x82, 0x02, 0xEB, 0x15, 0x4A, 0xC6, + 0x7C, 0x5A, 0x65, 0x2C, 0x63, 0x75, 0xCE, 0xC4, 0x6D, 0x33, 0x19, 0x98, 0x98, 0x98, 0xDE, 0x87, + 0xC9, 0xE1, 0xB7, 0xE7, 0x57, 0xD8, 0x4A, 0xB6, 0x51, 0xEA, 0xFF, 0xC9, 0x2A, 0x00, 0x02, 0x0B, + 0x45, 0x80, 0x89, 0xB5, 0xC9, 0x43, 0x86, 0x83, 0x1D, 0x08, 0xCC, 0x2C, 0x27, 0x34, 0x1C, 0x10, + 0x7A, 0x02, 0x63, 0x71, 0xE9, 0x9C, 0x80, 0x66, 0x34, 0x10, 0x89, 0x24, 0xC5, 0x42, 0x46, 0x3B, + 0x2E, 0x19, 0xAC, 0x58, 0x68, 0x14, 0xA8, 0x08, 0x3C, 0x64, 0xD1, 0xD1, 0x9E, 0x59, 0xFF, 0x00, + 0x1A, 0x39, 0xD5, 0xAE, 0x52, 0xB8, 0xE8, 0x2E, 0x42, 0x20, 0x94, 0x09, 0x51, 0xAD, 0x90, 0x91, + 0x13, 0x80, 0x64, 0x49, 0x54, 0xAD, 0x24, 0x40, 0x24, 0xE2, 0x11, 0x72, 0x79, 0xF4, 0x6E, 0xF0, + 0x4C, 0x0E, 0xF1, 0xBF, 0xEE, 0x03, 0x42, 0x45, 0x15, 0x2B, 0xA7, 0xAE, 0xD3, 0x18, 0xB6, 0x34, + 0x24, 0xCD, 0x0E, 0x45, 0x46, 0x00, 0x62, 0x03, 0x82, 0x04, 0xFC, 0x36, 0xD3, 0x5F, 0xF9, 0x54, + 0xDE, 0xD0, 0x17, 0x18, 0x38, 0x1C, 0x07, 0xD4, 0x2E, 0x6C, 0x93, 0xB9, 0x39, 0xFB, 0x3F, 0xBA, + 0x9A, 0xA6, 0x37, 0xFF, 0xFB, 0x92, 0x64, 0x43, 0x0F, 0x44, 0x36, 0x33, 0xCB, 0x13, 0x99, 0x43, + 0xD4, 0x35, 0x03, 0x29, 0xBA, 0x2D, 0x23, 0x46, 0x0F, 0x98, 0xC1, 0x2E, 0x0E, 0x64, 0xEF, 0x48, + 0xC6, 0x08, 0xA6, 0x68, 0xC3, 0x0C, 0x78, 0xAA, 0x40, 0x00, 0x00, 0x00, 0x26, 0x60, 0x01, 0x1D, + 0x01, 0x87, 0x87, 0x95, 0xBF, 0x1B, 0x0A, 0x04, 0x84, 0xC7, 0x47, 0x45, 0xC0, 0x9A, 0x4B, 0x49, + 0x5C, 0x44, 0x57, 0xC4, 0xD4, 0x02, 0x5A, 0x42, 0x6F, 0x97, 0xCA, 0x50, 0xCB, 0x0E, 0x81, 0x26, + 0xAE, 0x9D, 0x9F, 0xDC, 0x2B, 0x45, 0x29, 0x47, 0xFD, 0x19, 0x34, 0x4A, 0xA4, 0x50, 0x28, 0x61, + 0x10, 0x78, 0xB1, 0x80, 0xC7, 0xC5, 0x13, 0x05, 0x84, 0x8C, 0x28, 0x01, 0x32, 0xE3, 0x48, 0xCC, + 0xA1, 0xD3, 0x08, 0x80, 0x0E, 0x02, 0x13, 0x15, 0x13, 0x99, 0x20, 0x2E, 0x61, 0x40, 0x20, 0xA1, + 0x1C, 0xC7, 0x43, 0x83, 0x4F, 0x2D, 0x80, 0xC0, 0xF3, 0x0B, 0x87, 0x02, 0xD0, 0x93, 0x78, 0x82, + 0xA0, 0x52, 0x04, 0x01, 0x9A, 0x44, 0x2D, 0x66, 0x38, 0xF1, 0x18, 0x82, 0xB5, 0x37, 0x61, 0x0F, + 0x9A, 0xEB, 0x01, 0x87, 0x14, 0x55, 0x94, 0xB0, 0x37, 0x5D, 0x2C, 0x1C, 0xD7, 0x66, 0x07, 0xA6, + 0x5F, 0xEF, 0x33, 0x75, 0x61, 0xCD, 0x2A, 0x14, 0xBA, 0xD0, 0x52, 0x9A, 0xCB, 0xAC, 0xC7, 0xDD, + 0x4A, 0xA1, 0xC6, 0xA8, 0x8E, 0x23, 0x8A, 0xC6, 0xA7, 0x3D, 0x13, 0x5F, 0xD3, 0xF7, 0x13, 0xB0, + 0x8C, 0x24, 0x0A, 0x8C, 0x07, 0x41, 0x8B, 0x78, 0x59, 0x70, 0x0C, 0x00, 0x06, 0x0D, 0x02, 0x21, + 0x8B, 0xB0, 0x83, 0x82, 0x2F, 0xF7, 0xCD, 0x99, 0xC7, 0x34, 0xF9, 0x4E, 0x2C, 0xD4, 0x6E, 0xE3, + 0x96, 0xAB, 0x86, 0x1C, 0xD4, 0x0C, 0x14, 0x13, 0xBD, 0x22, 0x35, 0xBA, 0xD6, 0x29, 0x85, 0xB4, + 0xAA, 0xE6, 0xF6, 0xB2, 0xFE, 0xCF, 0xEB, 0x7F, 0x35, 0xF7, 0x13, 0x00, 0x02, 0x05, 0xBE, 0x82, + 0x53, 0x01, 0x03, 0xCE, 0x16, 0x29, 0x0C, 0x41, 0x94, 0x10, 0x0C, 0x60, 0x43, 0x30, 0x23, 0x5C, + 0xCA, 0xC8, 0x63, 0x58, 0x17, 0x8C, 0x14, 0x34, 0x32, 0x28, 0x00, 0xC3, 0x83, 0xC3, 0x14, 0x04, + 0x0C, 0x96, 0x4F, 0x33, 0x8C, 0xF4, 0xC1, 0xA2, 0x73, 0x1C, 0x8F, 0x82, 0x87, 0x44, 0x55, 0x3B, + 0x66, 0x46, 0x77, 0x0F, 0xD5, 0x4D, 0xC5, 0xF0, 0xCC, 0x87, 0xD3, 0xB6, 0xE8, 0xB7, 0xD9, 0x8B, + 0x80, 0x54, 0x02, 0x64, 0xAA, 0xAA, 0x83, 0x3D, 0xE0, 0x67, 0xAD, 0x66, 0x64, 0xE9, 0xA7, 0x23, + 0x66, 0xB3, 0x0C, 0xB8, 0xB0, 0x4C, 0x18, 0x42, 0xF3, 0xA9, 0x14, 0x22, 0x79, 0x90, 0x2A, 0x27, + 0xD3, 0x1B, 0x4F, 0x27, 0x2C, 0xCA, 0x27, 0x65, 0x0F, 0xBC, 0x2B, 0xF8, 0xF0, 0xC2, 0xAB, 0x94, + 0xA3, 0x20, 0x88, 0x09, 0xFE, 0x15, 0x17, 0x15, 0x07, 0x80, 0xB9, 0xC0, 0x40, 0x3F, 0x09, 0xFC, + 0x52, 0x32, 0x34, 0xFE, 0x59, 0x8E, 0xF8, 0x19, 0xB3, 0xA6, 0xD8, 0x00, 0x0A, 0xC0, 0x00, 0x04, + 0xE3, 0xE0, 0x0A, 0x93, 0xD1, 0xFF, 0xFB, 0x92, 0x64, 0x4D, 0x0F, 0x04, 0x7A, 0x34, 0x4A, 0x93, + 0x98, 0x3B, 0xE4, 0x30, 0x26, 0x19, 0xDD, 0x20, 0x22, 0x8C, 0x10, 0xD4, 0xD3, 0x2C, 0x0D, 0xE9, + 0x6F, 0x90, 0xC6, 0x09, 0xE6, 0xA8, 0x53, 0x09, 0x00, 0xE9, 0x7F, 0xC2, 0x57, 0xF2, 0x03, 0x08, + 0x3A, 0x1B, 0x42, 0xB7, 0x24, 0xC9, 0xD0, 0x26, 0x66, 0x7C, 0x9C, 0x83, 0x97, 0xDF, 0x2F, 0xCD, + 0xFF, 0xDB, 0xF2, 0x98, 0x85, 0x58, 0x41, 0x7C, 0x7F, 0xF9, 0x44, 0x7C, 0x0C, 0xBD, 0x57, 0x1F, + 0x93, 0x0D, 0x08, 0x34, 0x29, 0x60, 0x15, 0xB2, 0x2C, 0x04, 0x1B, 0x9D, 0xA5, 0x29, 0xA8, 0x9E, + 0x1C, 0x0C, 0x08, 0x54, 0x58, 0xD5, 0x81, 0x0C, 0x30, 0xF8, 0xC6, 0x0E, 0x4F, 0x0E, 0xB0, 0xC3, + 0xAA, 0x0B, 0x56, 0x61, 0x43, 0x01, 0x0A, 0xD7, 0xDB, 0x44, 0x45, 0x10, 0x48, 0x23, 0x82, 0x1C, + 0x38, 0xF1, 0x32, 0xC1, 0x09, 0x57, 0x65, 0x07, 0x98, 0xA2, 0x28, 0xBC, 0x09, 0x8A, 0xB4, 0x1A, + 0xE3, 0xAA, 0xFF, 0x36, 0xA8, 0x34, 0xA2, 0xEC, 0x65, 0x1C, 0xAD, 0xC7, 0x6C, 0xF5, 0xB8, 0xC3, + 0xCD, 0x19, 0x22, 0x45, 0x15, 0xCC, 0xD4, 0x64, 0x6A, 0x7D, 0xA5, 0xA8, 0x1B, 0xF4, 0xD9, 0xB9, + 0x23, 0x83, 0x22, 0xF0, 0x1E, 0x76, 0x3F, 0xEA, 0x56, 0x82, 0x6A, 0xEA, 0x54, 0x27, 0x92, 0xA3, + 0xFF, 0x86, 0x81, 0x44, 0xD4, 0xDA, 0x42, 0xAE, 0x39, 0xFE, 0x09, 0x07, 0x93, 0xAF, 0xF3, 0xEE, + 0x64, 0x4E, 0x97, 0xE2, 0xC9, 0x65, 0x08, 0x00, 0x00, 0x10, 0x58, 0x08, 0x6C, 0xCA, 0xC6, 0xE5, + 0x0D, 0x6F, 0x01, 0xA9, 0x15, 0xA6, 0x10, 0xF3, 0xEE, 0x7A, 0xB3, 0xB8, 0x73, 0x63, 0xC5, 0x41, + 0xE0, 0x74, 0xFC, 0xFC, 0x59, 0x1F, 0xDA, 0x2C, 0x5B, 0xC3, 0x8A, 0xBB, 0x5F, 0xFA, 0x05, 0x0D, + 0x9C, 0x22, 0x27, 0x18, 0x73, 0x61, 0x6A, 0x00, 0x02, 0x0D, 0xB0, 0xD2, 0x14, 0x98, 0x49, 0x7C, + 0xCC, 0x21, 0x40, 0x10, 0x58, 0xCA, 0x06, 0xD3, 0x0F, 0x9F, 0x8C, 0x82, 0x2C, 0x30, 0x4B, 0x70, + 0xC3, 0xC2, 0xC3, 0x04, 0x87, 0x81, 0x42, 0xE3, 0x0C, 0x11, 0x4C, 0x60, 0x08, 0x36, 0x09, 0x48, + 0xC9, 0x42, 0xB3, 0x07, 0x86, 0xD7, 0xA0, 0xCC, 0x43, 0x47, 0x3B, 0x83, 0x0A, 0x9F, 0x6E, 0x0A, + 0x80, 0x06, 0x84, 0x40, 0x3A, 0xB5, 0x2C, 0x0C, 0x5A, 0x28, 0xDB, 0xF1, 0x53, 0x23, 0x4A, 0xED, + 0xA2, 0x44, 0x23, 0x48, 0x34, 0x0F, 0x1A, 0x09, 0xAB, 0x43, 0x8F, 0x7E, 0x54, 0xE9, 0x4D, 0x3F, + 0x0F, 0x0E, 0x82, 0x64, 0x8C, 0x9C, 0x75, 0x04, 0x43, 0xE0, 0xE6, 0x24, 0x53, 0x5E, 0xA5, 0xAB, + 0x7A, 0x14, 0xEB, 0x52, 0xC9, 0xA1, 0xDB, 0x1E, 0xA0, 0xF2, 0x46, 0xCB, 0x8F, 0x24, 0x50, 0x89, + 0x12, 0x5B, 0xFF, 0xE3, 0xC1, 0xD0, 0x27, 0x25, 0x97, 0x6A, 0x10, 0xC5, 0x25, 0x53, 0x7E, 0xE5, + 0xDD, 0xFE, 0x97, 0x6C, 0x42, 0x57, 0x7A, 0xD0, 0xB4, 0x0E, 0x40, 0x00, 0x00, 0x0D, 0xE0, 0x44, + 0x92, 0xFB, 0xE8, 0xED, 0xD0, 0xD4, 0x1F, 0xFF, 0xFB, 0x92, 0x64, 0x50, 0x06, 0x04, 0x82, 0x34, + 0x4A, 0x93, 0x99, 0x5B, 0xE4, 0x32, 0x68, 0xF9, 0xBD, 0x08, 0x23, 0xAC, 0x11, 0xE8, 0xC9, 0x28, + 0xCE, 0x69, 0x6D, 0xC0, 0xCB, 0x23, 0xA8, 0x28, 0xC0, 0x88, 0x7B, 0xD8, 0x15, 0x91, 0x00, 0x43, + 0x7A, 0x33, 0x86, 0xB0, 0xDF, 0xA8, 0x11, 0xB8, 0x64, 0x2F, 0xEB, 0xF2, 0xFF, 0xCD, 0xBC, 0xBE, + 0x45, 0xE3, 0xFF, 0xFB, 0xB3, 0xD5, 0x28, 0x93, 0xA0, 0xEF, 0xA2, 0x7E, 0x74, 0x4C, 0x03, 0x02, + 0xE5, 0x6A, 0x40, 0x93, 0x49, 0xC7, 0xB6, 0x42, 0xC5, 0xA0, 0x11, 0xD8, 0x31, 0x44, 0x61, 0x36, + 0x89, 0xAC, 0xCA, 0xA6, 0x2A, 0x7B, 0x99, 0x0C, 0x0E, 0x63, 0x63, 0x89, 0x84, 0x09, 0x66, 0x58, + 0x01, 0x1A, 0x25, 0xD6, 0x61, 0x0E, 0x1B, 0xC6, 0x06, 0x55, 0xC9, 0xC4, 0x14, 0x3C, 0xB1, 0x84, + 0x34, 0xE0, 0x29, 0x73, 0x80, 0x28, 0x70, 0x01, 0x40, 0xF9, 0x0C, 0xF4, 0x51, 0x1D, 0x8B, 0xC4, + 0x09, 0x09, 0x1A, 0x2D, 0xDA, 0xCB, 0x60, 0xED, 0x44, 0x50, 0x02, 0x2B, 0x2E, 0x44, 0xBF, 0x4D, + 0x62, 0xD1, 0x44, 0x2E, 0xBC, 0x29, 0xD6, 0xBE, 0x65, 0xE0, 0x90, 0xA2, 0xCC, 0xD6, 0xFC, 0xBD, + 0x83, 0x2B, 0x1B, 0x02, 0x65, 0xD1, 0x6C, 0xB3, 0x6E, 0xAE, 0x7C, 0xB5, 0xE0, 0x7D, 0x73, 0x83, + 0xAB, 0x78, 0x0F, 0x81, 0x3F, 0x86, 0xB4, 0xC0, 0xDF, 0xFF, 0xFF, 0x3E, 0x4D, 0x1E, 0x81, 0xC8, + 0xA7, 0x6A, 0x5A, 0xA4, 0x80, 0xED, 0x9C, 0x03, 0x15, 0xFF, 0xAF, 0xE8, 0xDD, 0x82, 0x90, 0x80, + 0x09, 0x21, 0x28, 0x0E, 0x0A, 0x36, 0xEF, 0x64, 0xF1, 0xFF, 0x63, 0xEB, 0x6A, 0x2F, 0xFB, 0x7B, + 0xC9, 0x10, 0xCA, 0x92, 0xB2, 0x93, 0x3B, 0xB2, 0x53, 0xFF, 0xBF, 0xFF, 0xFF, 0xA2, 0x93, 0xDE, + 0x6E, 0x96, 0xF5, 0x08, 0x25, 0x18, 0xE4, 0xD9, 0xD0, 0xB2, 0x83, 0x55, 0x6C, 0xE0, 0xDC, 0x7D, + 0x01, 0x1F, 0x02, 0x00, 0xF3, 0x0A, 0x24, 0x3C, 0xAC, 0xD3, 0x47, 0x22, 0x33, 0xF3, 0x03, 0x2A, + 0x2A, 0x39, 0x4F, 0x83, 0xCB, 0x1E, 0x04, 0xA7, 0x1A, 0x40, 0x10, 0x31, 0xE0, 0x2E, 0x32, 0x6C, + 0xA6, 0xA2, 0x10, 0xE3, 0xEA, 0xE1, 0x30, 0xF0, 0x03, 0x1F, 0x07, 0x16, 0x18, 0x0E, 0xB7, 0x60, + 0xE2, 0x00, 0x72, 0xFD, 0x9B, 0x35, 0x97, 0x30, 0xA1, 0x26, 0x58, 0xAC, 0x49, 0xA7, 0xA1, 0x61, + 0x10, 0x40, 0xA2, 0x83, 0x80, 0x96, 0xA1, 0x3A, 0xDA, 0x88, 0xC0, 0xC1, 0x23, 0x20, 0x89, 0x3D, + 0xDA, 0xAA, 0x99, 0xC2, 0x6F, 0x36, 0x34, 0x45, 0x5F, 0x28, 0xC4, 0xC8, 0xCC, 0x01, 0x1D, 0xC6, + 0x67, 0xA4, 0x82, 0x77, 0x5D, 0xA0, 0x35, 0xCA, 0xE0, 0x96, 0x4E, 0x10, 0x3E, 0xA8, 0x1D, 0x1E, + 0x07, 0x43, 0x3D, 0x42, 0x1A, 0xFF, 0xFF, 0xC8, 0xA3, 0xA4, 0x88, 0x46, 0x25, 0x0D, 0x63, 0x79, + 0xB9, 0xF6, 0x10, 0xD9, 0x79, 0x42, 0x15, 0xFF, 0xD1, 0x52, 0xAF, 0x9B, 0x40, 0x10, 0x20, 0x00, + 0x11, 0x98, 0x0E, 0x92, 0xC4, 0x87, 0x5A, 0x11, 0xC3, 0xFF, 0xFB, 0x92, 0x64, 0x4C, 0x8F, 0x04, + 0x60, 0x33, 0xCA, 0x0B, 0x79, 0x5C, 0x44, 0x31, 0xC3, 0x49, 0xCA, 0x18, 0x23, 0xA0, 0x11, 0xEC, + 0xCF, 0x24, 0x0E, 0x61, 0xF2, 0xD0, 0xAD, 0x81, 0x28, 0xA4, 0x21, 0x08, 0x06, 0x67, 0x2D, 0x35, + 0xFE, 0x51, 0x31, 0x2B, 0xB7, 0x24, 0x54, 0xDD, 0x77, 0xB0, 0x5A, 0xAA, 0xF1, 0x3E, 0x7C, 0xB1, + 0x0C, 0x42, 0xDD, 0xE8, 0xFA, 0xBF, 0xAB, 0x7D, 0xFE, 0xAD, 0x07, 0x9F, 0x8B, 0xA5, 0x4F, 0x7A, + 0x58, 0x46, 0x34, 0xD6, 0x10, 0x92, 0x76, 0xDF, 0xF1, 0x8B, 0x00, 0x46, 0x2E, 0x0F, 0x18, 0x41, + 0x98, 0x69, 0x15, 0x12, 0x9D, 0x18, 0x5C, 0xD0, 0x2C, 0x6B, 0x30, 0x79, 0x60, 0x94, 0xE0, 0x58, + 0x3A, 0x9C, 0x84, 0x38, 0x76, 0x78, 0x71, 0x08, 0xB8, 0xC9, 0x84, 0xB3, 0x00, 0x18, 0x4C, 0x7C, + 0x34, 0x30, 0x50, 0x09, 0x98, 0x0A, 0x81, 0x4C, 0xFE, 0x1A, 0x2F, 0x22, 0xD4, 0x48, 0x24, 0x22, + 0x4F, 0xD4, 0xE7, 0x21, 0xD0, 0xFD, 0x1B, 0x32, 0x7A, 0x88, 0x6A, 0x24, 0x26, 0xA2, 0xB0, 0xE4, + 0xC7, 0x67, 0xC4, 0xC7, 0x56, 0xC1, 0xA2, 0x63, 0x5B, 0x06, 0x10, 0xE4, 0x88, 0x96, 0x22, 0x10, + 0x3E, 0x2B, 0xB5, 0x2F, 0x04, 0x00, 0x28, 0x13, 0xDB, 0x53, 0xE0, 0xCC, 0x2F, 0xF7, 0x92, 0x52, + 0xD5, 0xD6, 0xFE, 0x54, 0x91, 0x8B, 0xE3, 0xAD, 0xFB, 0x3E, 0xF9, 0xFB, 0xF4, 0xA6, 0x6F, 0x2A, + 0x72, 0x77, 0x2A, 0x1A, 0xCF, 0x97, 0xDF, 0x63, 0xF5, 0x4A, 0x98, 0xDD, 0xDF, 0xFF, 0xF7, 0xDC, + 0xE4, 0x68, 0x20, 0x22, 0x84, 0xAC, 0x01, 0x41, 0x38, 0x21, 0xE4, 0x85, 0x9C, 0xDA, 0x92, 0x94, + 0x50, 0xF3, 0xA6, 0xC2, 0x43, 0x8D, 0x69, 0x91, 0x43, 0x75, 0xD6, 0x63, 0x90, 0xBB, 0xD4, 0x48, + 0xD9, 0x87, 0x42, 0x8B, 0xF9, 0x77, 0x4B, 0x65, 0x9F, 0xCB, 0x47, 0xC1, 0x05, 0x5D, 0xA8, 0xE4, + 0x88, 0x87, 0xCC, 0x4A, 0x9B, 0x40, 0x04, 0x61, 0xC0, 0xB0, 0x22, 0x30, 0x66, 0xD7, 0x09, 0x8C, + 0x4C, 0xC6, 0xF5, 0x05, 0x87, 0x2C, 0xCC, 0x42, 0xBD, 0x31, 0x90, 0xBC, 0xC0, 0x03, 0x13, 0x31, + 0x22, 0x8E, 0xFD, 0x01, 0x30, 0x90, 0x00, 0xC5, 0x02, 0x63, 0x26, 0x68, 0xED, 0x0D, 0x05, 0x0F, + 0x02, 0x08, 0x30, 0xE2, 0x49, 0x42, 0x25, 0xD1, 0x81, 0x02, 0x24, 0x05, 0xB9, 0x21, 0x2C, 0xB6, + 0x41, 0x41, 0x8A, 0x56, 0xBB, 0x52, 0x35, 0x1C, 0x99, 0x53, 0x09, 0x41, 0x64, 0xC6, 0x76, 0x5B, + 0x20, 0x84, 0x03, 0xB9, 0x3F, 0x69, 0x9E, 0x2C, 0x0D, 0xE2, 0x00, 0x2A, 0x6E, 0x6B, 0xCC, 0xA1, + 0x13, 0xAE, 0x80, 0x37, 0x19, 0x07, 0xDE, 0xA1, 0xC1, 0xF5, 0x79, 0x2B, 0x2B, 0xBB, 0xE4, 0xDC, + 0x0E, 0xB0, 0xCB, 0xFF, 0xC8, 0x97, 0x98, 0x16, 0xB0, 0x76, 0x30, 0xA8, 0x1D, 0x1E, 0x34, 0x3E, + 0x1B, 0x22, 0xB5, 0x6D, 0x0F, 0xD6, 0x09, 0x8B, 0x80, 0x05, 0x86, 0x4F, 0xAD, 0x2E, 0xF3, 0x8A, + 0x01, 0xEA, 0x97, 0x6A, 0x04, 0x78, 0x90, 0x75, 0x5C, 0x7D, 0x4B, 0xFF, 0xFB, 0x92, 0x64, 0x4F, + 0x0E, 0x04, 0x59, 0x33, 0xC9, 0x03, 0x9A, 0x5B, 0xD0, 0x33, 0x83, 0x49, 0x52, 0x18, 0x66, 0x44, + 0x10, 0x70, 0xC3, 0x28, 0x2E, 0x61, 0x2F, 0x50, 0xD1, 0xA4, 0x26, 0xB4, 0x53, 0x0A, 0x48, 0x0C, + 0x82, 0xBB, 0xC2, 0xCB, 0xFA, 0x9B, 0xBE, 0xB3, 0xBC, 0xDB, 0x28, 0xA0, 0x29, 0xBA, 0xC7, 0xA4, + 0xA6, 0x8F, 0xEA, 0x28, 0xD0, 0xFE, 0x58, 0x1F, 0xF2, 0x9D, 0x6D, 0x76, 0x5B, 0x96, 0x9F, 0x59, + 0x24, 0xB4, 0x86, 0x09, 0x0C, 0x9E, 0x04, 0x62, 0x0E, 0x82, 0x8F, 0x12, 0x4C, 0x2C, 0x7E, 0x30, + 0x48, 0xFC, 0xD1, 0x63, 0x33, 0x33, 0x19, 0x42, 0x0D, 0x26, 0x3A, 0x4C, 0x18, 0x54, 0x4A, 0x09, + 0x03, 0x98, 0xD0, 0x66, 0x69, 0x96, 0xC1, 0x85, 0xC7, 0x86, 0x02, 0x12, 0x02, 0xC6, 0x0E, 0x92, + 0xCA, 0x47, 0x21, 0xAA, 0x9D, 0x6E, 0xB0, 0xC9, 0x12, 0xA1, 0xA2, 0xC0, 0x72, 0x9A, 0xD2, 0x09, + 0x82, 0x1C, 0x85, 0xA5, 0xD4, 0x63, 0xA4, 0xC6, 0x68, 0xA8, 0x84, 0x80, 0x87, 0xB6, 0x01, 0x45, + 0xA0, 0x16, 0x60, 0xFD, 0xB6, 0x41, 0x00, 0x19, 0x9A, 0xFB, 0x58, 0x11, 0x81, 0x2C, 0xF6, 0xE3, + 0x0C, 0xBF, 0x30, 0x41, 0x15, 0xE4, 0x09, 0x55, 0x1A, 0x4C, 0xDE, 0xFF, 0x78, 0xB5, 0xFF, 0xFF, + 0xF6, 0x47, 0x9D, 0x60, 0x93, 0x9B, 0xA0, 0xC2, 0x76, 0x6C, 0xC2, 0xA9, 0xB3, 0xD4, 0x0A, 0xA7, + 0xFF, 0xC9, 0xF5, 0x20, 0x1C, 0x20, 0x00, 0xC0, 0x06, 0x99, 0x80, 0x16, 0x7F, 0x7A, 0x53, 0xF5, + 0x0C, 0x9E, 0xD8, 0xCD, 0x1C, 0x44, 0x94, 0xDF, 0x9A, 0x5B, 0x66, 0x50, 0xCB, 0xD8, 0xF0, 0x43, + 0x4C, 0xCD, 0x4E, 0x9B, 0xED, 0xC3, 0x7F, 0xAF, 0xFA, 0xFF, 0xF3, 0x1F, 0xFE, 0xDF, 0xE4, 0xB3, + 0x2A, 0xA9, 0x1B, 0xF6, 0x45, 0xAA, 0x46, 0x75, 0x02, 0x1D, 0x98, 0x51, 0x00, 0x54, 0xF9, 0x49, + 0x13, 0x27, 0x04, 0x8C, 0x00, 0x62, 0x30, 0xE0, 0x24, 0xE0, 0xE3, 0xC3, 0x70, 0x8E, 0x0C, 0x32, + 0xC8, 0x02, 0x10, 0x8C, 0x7A, 0x8B, 0x30, 0x58, 0x74, 0xC4, 0x07, 0xE3, 0x15, 0x9D, 0x8E, 0x10, + 0x8F, 0x30, 0x11, 0x08, 0xC6, 0x26, 0xF3, 0x26, 0x87, 0xD3, 0x50, 0x38, 0x56, 0xA5, 0xA2, 0x40, + 0x10, 0x52, 0x38, 0xBB, 0x8A, 0xBC, 0x70, 0x62, 0xF5, 0x5C, 0xAE, 0x28, 0x84, 0xC5, 0xA1, 0xE4, + 0x32, 0x81, 0xD0, 0x22, 0xCB, 0x64, 0x68, 0x0D, 0x81, 0x5B, 0x88, 0x08, 0x05, 0x9E, 0x73, 0xDA, + 0x1D, 0x1A, 0xF8, 0x4A, 0xB0, 0x49, 0x84, 0x76, 0x3D, 0x8E, 0x06, 0x80, 0x0B, 0x63, 0x2B, 0x76, + 0x29, 0x1E, 0x49, 0x46, 0x16, 0x62, 0x70, 0x66, 0x7D, 0x76, 0x6D, 0x78, 0x8A, 0x77, 0xEA, 0x41, + 0x71, 0x59, 0x11, 0xA8, 0xF8, 0xE3, 0xA8, 0xD0, 0x22, 0x12, 0x1F, 0xA4, 0x00, 0x18, 0x70, 0x01, + 0x12, 0xFE, 0x06, 0x4C, 0xFC, 0x03, 0x27, 0xB1, 0x5F, 0xF6, 0xA9, 0x86, 0xAD, 0xE5, 0xB7, 0xA2, + 0xE9, 0x17, 0x89, 0xC3, 0xCF, 0x20, 0xB2, 0x0E, 0xA1, 0x2E, 0x25, 0x93, 0xD1, 0xFF, 0xFB, 0x92, + 0x64, 0x52, 0x8E, 0x64, 0x1E, 0x2F, 0x49, 0x8B, 0x98, 0x3C, 0xC0, 0x33, 0xE3, 0x79, 0x63, 0x04, + 0x06, 0x18, 0x12, 0x18, 0xBF, 0x22, 0x2E, 0xED, 0xAD, 0xD0, 0xBE, 0x1C, 0x67, 0x28, 0x10, 0x8E, + 0x3A, 0xDB, 0x55, 0x6F, 0x56, 0xB5, 0x85, 0x36, 0xA8, 0x3B, 0x79, 0x83, 0xE6, 0x12, 0x59, 0xA5, + 0xE1, 0x61, 0x89, 0x49, 0x1F, 0xD8, 0x68, 0x46, 0x47, 0x9C, 0x33, 0x4B, 0x91, 0x27, 0xC6, 0x20, + 0x89, 0xC6, 0x72, 0x92, 0x66, 0xBA, 0x0A, 0xE6, 0x45, 0x8A, 0x26, 0x1C, 0x3C, 0x22, 0x20, 0x8C, + 0xC1, 0x33, 0x00, 0xB0, 0x04, 0x99, 0x92, 0x4E, 0x99, 0x4E, 0x1B, 0x1D, 0x6A, 0x70, 0x91, 0xA1, + 0xA1, 0xAC, 0x81, 0x9A, 0x4E, 0x38, 0x89, 0x27, 0x48, 0x81, 0x93, 0x28, 0xC1, 0xCA, 0x4C, 0x2C, + 0x04, 0x30, 0x2D, 0x69, 0x84, 0x10, 0x97, 0xB5, 0x48, 0x0E, 0x0A, 0x2C, 0xD8, 0x68, 0x58, 0x0D, + 0x13, 0x44, 0x89, 0x9D, 0x30, 0x20, 0x21, 0x82, 0x86, 0xB8, 0x4C, 0x94, 0x40, 0x16, 0x1C, 0x03, + 0x04, 0x2C, 0xE5, 0x5E, 0xAD, 0xB0, 0xA0, 0xA8, 0x58, 0x34, 0x00, 0xD0, 0xC1, 0x13, 0x1E, 0x03, + 0x43, 0xAB, 0x88, 0xA6, 0x8B, 0x1A, 0x01, 0x42, 0xBC, 0x70, 0x68, 0x8D, 0x8A, 0x15, 0x18, 0x87, + 0xAD, 0xB7, 0x38, 0xDF, 0xD2, 0xD2, 0x31, 0x40, 0xD9, 0x6A, 0x7A, 0x25, 0xD1, 0x46, 0xEF, 0xFA, + 0x37, 0x7A, 0xAC, 0xC2, 0xCC, 0x00, 0xE3, 0x01, 0x89, 0x7F, 0xFE, 0x7D, 0x83, 0xB2, 0x4E, 0xDB, + 0x92, 0x6D, 0xC1, 0x51, 0x42, 0x02, 0xC8, 0xE7, 0xAF, 0xFB, 0xC0, 0xBF, 0x31, 0x0D, 0x78, 0x98, + 0x84, 0xF6, 0xF5, 0x18, 0xFE, 0x54, 0x0E, 0x15, 0x59, 0x05, 0x10, 0x84, 0xC0, 0xCA, 0x5E, 0x35, + 0x5E, 0x22, 0x17, 0x34, 0x00, 0xC7, 0x0A, 0xAC, 0xF8, 0xC1, 0x43, 0xF3, 0xE1, 0x2E, 0x4E, 0x76, + 0x73, 0x03, 0x09, 0xCC, 0x1E, 0x7A, 0x34, 0x07, 0x60, 0x14, 0x35, 0x31, 0x2C, 0xD8, 0xC9, 0x46, + 0x43, 0x0B, 0xB0, 0xCC, 0x78, 0x80, 0x34, 0x81, 0x2C, 0xD9, 0x42, 0x63, 0x8D, 0x90, 0x07, 0x9D, + 0x86, 0x39, 0x55, 0x19, 0x40, 0xB0, 0x60, 0x51, 0x0B, 0xBC, 0xA1, 0x06, 0x03, 0x0C, 0x9A, 0x04, + 0x14, 0xCA, 0x88, 0x40, 0xA8, 0xCE, 0x52, 0x14, 0x13, 0xB2, 0x09, 0x5A, 0x66, 0xAD, 0x58, 0x78, + 0x46, 0x80, 0x81, 0x5D, 0x21, 0x61, 0x1B, 0x91, 0xED, 0x92, 0xAD, 0x26, 0x91, 0x10, 0x9F, 0x59, + 0x85, 0xF3, 0x81, 0x46, 0x92, 0xD3, 0x42, 0x54, 0x9D, 0x31, 0xE6, 0x97, 0xB9, 0xD6, 0x24, 0xD6, + 0xDA, 0xD6, 0x72, 0x45, 0xDB, 0x9C, 0x8A, 0x8E, 0x18, 0xEB, 0x27, 0x6F, 0xEB, 0xFF, 0x09, 0x82, + 0xA8, 0xDC, 0x3E, 0xFF, 0x77, 0xB5, 0xCA, 0x4F, 0x90, 0xC4, 0xF6, 0x00, 0x00, 0x00, 0x05, 0x57, + 0x81, 0x08, 0x23, 0x49, 0x8F, 0x21, 0x0E, 0x64, 0x85, 0xB4, 0xCD, 0x3A, 0x2A, 0xD9, 0x6A, 0x84, + 0x60, 0xEC, 0x9A, 0xE7, 0x5E, 0xB4, 0x6F, 0xFF, 0xCB, 0xFF, 0x6A, 0x7C, 0xA9, 0xF6, 0x67, 0xFF, + 0xFB, 0x92, 0x64, 0x55, 0x8E, 0x44, 0x33, 0x2F, 0xC9, 0x93, 0x98, 0x54, 0xC0, 0x32, 0xC8, 0x79, + 0xAA, 0x08, 0x02, 0x1A, 0x0F, 0x68, 0xBD, 0x2C, 0x4E, 0x65, 0x0F, 0x40, 0xCE, 0x94, 0x65, 0xA8, + 0x50, 0x08, 0xD8, 0x45, 0x7A, 0x5A, 0x6E, 0x63, 0x99, 0xC1, 0x29, 0x8B, 0xEC, 0x0C, 0xF2, 0x68, + 0x0B, 0x1E, 0x14, 0xCC, 0x6C, 0xC2, 0xE2, 0x23, 0x40, 0x8F, 0xCD, 0x4E, 0x22, 0x0C, 0x0F, 0x22, + 0x51, 0xA4, 0x7A, 0xA6, 0x7D, 0x12, 0x99, 0x4D, 0x22, 0x65, 0xB1, 0x69, 0x9B, 0x8E, 0x46, 0x03, + 0x0C, 0x98, 0x9C, 0x4E, 0x60, 0x63, 0x89, 0xAB, 0x15, 0x26, 0x7B, 0x24, 0x99, 0x50, 0x5C, 0x22, + 0x24, 0x16, 0xB2, 0x11, 0x8C, 0x28, 0x4A, 0xC8, 0x88, 0x44, 0xEB, 0x87, 0x22, 0xE5, 0x06, 0x41, + 0x91, 0xE5, 0x1F, 0x79, 0x69, 0x5A, 0xE3, 0x3F, 0x76, 0xA7, 0x16, 0x19, 0x28, 0xE5, 0x55, 0xE1, + 0xC7, 0x9A, 0x10, 0xD0, 0x1C, 0xB6, 0xCD, 0x14, 0x52, 0x80, 0x42, 0x02, 0xA1, 0xAD, 0xE9, 0x53, + 0x08, 0x9E, 0x83, 0x98, 0x56, 0x9C, 0x38, 0x7C, 0x1D, 0x0B, 0xD5, 0xFF, 0x35, 0xD3, 0xBB, 0x57, + 0x7F, 0xFF, 0x11, 0x82, 0xB0, 0x6E, 0x1F, 0x05, 0x3A, 0x93, 0xFE, 0xAD, 0x80, 0x40, 0x00, 0x10, + 0x38, 0x04, 0x29, 0x68, 0x46, 0xF0, 0x1D, 0xC2, 0x03, 0x46, 0x04, 0xAD, 0x62, 0x50, 0x04, 0x2A, + 0x16, 0x8C, 0x38, 0x72, 0x10, 0xE3, 0xB8, 0x0D, 0x51, 0xF6, 0x7C, 0xDB, 0x5D, 0x09, 0x23, 0xDF, + 0xCE, 0x2F, 0xD6, 0xFF, 0x6B, 0x14, 0x96, 0x20, 0x5D, 0x99, 0x57, 0xBD, 0xD5, 0x1D, 0x86, 0x68, + 0x01, 0x26, 0x52, 0xB4, 0xC2, 0xA0, 0xC4, 0xC8, 0xB6, 0x10, 0x31, 0xCF, 0x30, 0x24, 0x0F, 0x33, + 0x24, 0x3E, 0x3B, 0xC0, 0x31, 0x39, 0x3C, 0x82, 0x30, 0x78, 0xA8, 0x30, 0x8C, 0xA3, 0x30, 0x6D, + 0xFD, 0x33, 0x0C, 0x5D, 0x33, 0x40, 0x60, 0x37, 0x58, 0x89, 0x33, 0x06, 0xAC, 0x30, 0x50, 0xB3, + 0x30, 0x78, 0x5C, 0x34, 0x91, 0x53, 0xEE, 0x56, 0x1E, 0x2D, 0x31, 0x46, 0x40, 0x65, 0xB0, 0x78, + 0x01, 0x10, 0xA4, 0x25, 0x95, 0x4A, 0x84, 0x65, 0x77, 0x57, 0x61, 0x82, 0x08, 0x5B, 0x49, 0xC1, + 0xD0, 0xA7, 0x3D, 0xB2, 0x2A, 0x2B, 0x41, 0x60, 0x02, 0x0C, 0x86, 0x00, 0x00, 0x07, 0x4F, 0xC4, + 0x53, 0x5E, 0x89, 0x7A, 0x3A, 0x7D, 0x49, 0xC7, 0x82, 0xA1, 0x0D, 0x7C, 0x23, 0x20, 0x78, 0x30, + 0x7C, 0x38, 0xA5, 0x4F, 0xE6, 0x15, 0xF1, 0xC3, 0x6A, 0x3F, 0x43, 0x94, 0xA1, 0x4C, 0x1A, 0x5D, + 0xDE, 0xEA, 0x37, 0x76, 0x46, 0xFF, 0xD3, 0xFE, 0xD9, 0x04, 0xE7, 0xEE, 0xA6, 0xB9, 0xFF, 0xFE, + 0xF0, 0x42, 0x60, 0x08, 0x14, 0x80, 0x33, 0x94, 0xE2, 0xE1, 0xFF, 0xFB, 0x96, 0x47, 0x2F, 0x6A, + 0xC7, 0xCF, 0x5D, 0x51, 0x61, 0xA8, 0xDE, 0x00, 0xC0, 0x00, 0x00, 0x01, 0x04, 0x2F, 0x02, 0x4E, + 0x41, 0x2F, 0x44, 0x25, 0x89, 0xD5, 0xA8, 0xC5, 0x54, 0x97, 0xD2, 0x58, 0x88, 0xC0, 0x93, 0x3E, + 0xE6, 0xFF, 0xFB, 0x92, 0x64, 0x60, 0x8F, 0x05, 0x37, 0x34, 0x48, 0x0B, 0xBB, 0xD3, 0x80, 0x2C, + 0xC3, 0x39, 0xBD, 0x04, 0x05, 0x36, 0x13, 0x08, 0xD3, 0x24, 0x0E, 0xE9, 0xF1, 0x10, 0xCB, 0x10, + 0xE7, 0x34, 0x20, 0x8D, 0x78, 0xEE, 0x67, 0xF5, 0xF4, 0xC5, 0x91, 0xA8, 0x89, 0x6A, 0x64, 0x4B, + 0x99, 0x24, 0x52, 0x91, 0x85, 0x8B, 0x97, 0x7B, 0x94, 0x9C, 0xA6, 0x02, 0x81, 0x86, 0xBC, 0x14, + 0x06, 0x25, 0x82, 0x00, 0x90, 0x84, 0xC7, 0xE1, 0x0C, 0xD3, 0x7B, 0xF0, 0xC6, 0x11, 0x48, 0x51, + 0x29, 0x30, 0x50, 0x42, 0x32, 0x41, 0x66, 0x10, 0x86, 0x60, 0x65, 0xFC, 0xC0, 0x81, 0x28, 0xD5, + 0xC5, 0xAC, 0xC2, 0x80, 0x5C, 0xC0, 0xC1, 0x74, 0xC3, 0x60, 0x78, 0xC8, 0x20, 0xC4, 0xB3, 0x60, + 0xA0, 0xD4, 0xC5, 0x41, 0x36, 0x64, 0x42, 0x04, 0x3C, 0x09, 0x88, 0x03, 0x01, 0x02, 0x33, 0xC0, + 0x41, 0x10, 0x70, 0x38, 0xA2, 0x76, 0x98, 0xC9, 0xED, 0x02, 0x3E, 0x28, 0x64, 0x0C, 0x31, 0xD1, + 0x79, 0x5A, 0x52, 0x49, 0xF6, 0x1E, 0x5B, 0x89, 0x47, 0x42, 0xC8, 0x48, 0x61, 0x9B, 0x40, 0x8A, + 0x73, 0x8B, 0x72, 0x83, 0x71, 0xA9, 0x33, 0x0E, 0x0A, 0x33, 0x9C, 0xC8, 0x70, 0xAD, 0x5A, 0xF8, + 0x69, 0xBB, 0x43, 0x2B, 0x4F, 0xEA, 0x76, 0x5D, 0xE1, 0x95, 0xB7, 0xFF, 0xF0, 0xBA, 0x70, 0x48, + 0x46, 0x70, 0x24, 0x90, 0xB5, 0xFF, 0xCC, 0xAE, 0xF7, 0x47, 0x5A, 0xFE, 0x2B, 0x72, 0xFA, 0x92, + 0x88, 0x00, 0x0E, 0x00, 0x00, 0x5B, 0x3F, 0x01, 0x5C, 0xD8, 0x66, 0xFF, 0x37, 0x9B, 0x36, 0x8D, + 0x17, 0xF3, 0x1F, 0x9F, 0x91, 0xE8, 0x81, 0xF3, 0xAE, 0xA1, 0x7C, 0x7A, 0x35, 0x54, 0x4E, 0xFB, + 0x0B, 0xBF, 0x49, 0x22, 0x7A, 0x1C, 0x04, 0x47, 0x84, 0xF2, 0x2C, 0x03, 0xDC, 0x07, 0x44, 0x22, + 0x09, 0x38, 0x75, 0x01, 0x27, 0x67, 0xC0, 0x05, 0x03, 0xB6, 0xF8, 0x8D, 0x0C, 0x0A, 0x2F, 0xB0, + 0x25, 0x66, 0x7C, 0x73, 0xE8, 0x19, 0x8A, 0x67, 0x3A, 0x01, 0x83, 0x8A, 0xA6, 0xDF, 0x8D, 0x88, + 0xCC, 0x46, 0x0A, 0x7B, 0x9A, 0xC0, 0x82, 0x7C, 0xFC, 0x61, 0x88, 0x46, 0x24, 0x01, 0x21, 0x09, + 0x28, 0xD3, 0x63, 0xD6, 0x30, 0x61, 0x70, 0x58, 0xE6, 0x13, 0x42, 0x48, 0x2C, 0x2C, 0x99, 0x80, + 0x8C, 0xE1, 0xA0, 0x17, 0x0C, 0x34, 0xA0, 0x49, 0x85, 0xD1, 0x2D, 0x7F, 0xD4, 0xDC, 0x2E, 0x01, + 0x49, 0x02, 0x02, 0x94, 0x31, 0x58, 0x46, 0xCF, 0x50, 0x78, 0x35, 0xE9, 0xD5, 0xBC, 0x81, 0xD9, + 0xB9, 0x60, 0x40, 0xE7, 0x28, 0x22, 0xBF, 0x89, 0xAB, 0x73, 0x36, 0x8B, 0xC7, 0x1A, 0x04, 0x09, + 0x5E, 0xB5, 0x7E, 0x3C, 0x31, 0x97, 0xC3, 0x9E, 0x0F, 0x6A, 0x43, 0x41, 0xA7, 0x58, 0x2F, 0x2E, + 0x91, 0x10, 0xAB, 0x7F, 0xFD, 0xE9, 0x89, 0xE4, 0x68, 0x6C, 0x37, 0x9F, 0xDD, 0x8C, 0xBD, 0xBA, + 0x15, 0xFF, 0x7F, 0xD9, 0xB1, 0xD0, 0x81, 0x68, 0xC0, 0x00, 0x01, 0x8F, 0x70, 0x20, 0x32, 0xB0, + 0xAC, 0x90, 0x3C, 0xFF, 0xFB, 0x92, 0x64, 0x50, 0x0E, 0x04, 0x93, 0x34, 0x49, 0x0B, 0x9A, 0x4C, + 0x54, 0x2D, 0x01, 0xC9, 0xDD, 0x24, 0x23, 0x0E, 0x11, 0x2C, 0xD1, 0x2A, 0x6E, 0x69, 0x6F, 0x40, + 0xC2, 0xA2, 0xA6, 0xE8, 0x30, 0x8A, 0x9B, 0xF0, 0x34, 0x60, 0x50, 0xC1, 0xDB, 0x61, 0x68, 0xFB, + 0x72, 0xC5, 0x69, 0x36, 0x8D, 0x54, 0x33, 0xC9, 0xFB, 0xB8, 0xB8, 0x78, 0x6F, 0xF7, 0x2D, 0xE9, + 0x71, 0xF9, 0x52, 0x02, 0xC0, 0x52, 0x60, 0x4B, 0x9E, 0xA4, 0x3F, 0x9F, 0x34, 0xE2, 0xBC, 0x7A, + 0x90, 0x30, 0x0A, 0x31, 0x5A, 0x24, 0xD2, 0x83, 0x33, 0x5A, 0x0C, 0x8C, 0x8A, 0x49, 0x4E, 0x43, + 0x4B, 0x26, 0x0C, 0x0C, 0x42, 0x65, 0xA6, 0xF4, 0x13, 0x1F, 0x08, 0xB2, 0x61, 0x81, 0x98, 0xA0, + 0xEC, 0x30, 0x49, 0xEB, 0x50, 0xDD, 0xC5, 0x8B, 0x03, 0x07, 0x9C, 0x20, 0x09, 0x7A, 0x99, 0x82, + 0x22, 0x0C, 0x1A, 0xB5, 0x09, 0x01, 0x89, 0x4C, 0xCC, 0x64, 0x80, 0x23, 0xB2, 0xEB, 0x2D, 0x29, + 0x14, 0x62, 0xD5, 0x25, 0xAC, 0x72, 0xB0, 0x50, 0x07, 0x73, 0xAF, 0x49, 0x42, 0xD6, 0xDA, 0x17, + 0x36, 0xBD, 0x88, 0xE2, 0xA1, 0xFC, 0x70, 0x69, 0x07, 0x2C, 0xC4, 0xB0, 0x10, 0x7D, 0x42, 0x49, + 0x67, 0x07, 0x96, 0xCD, 0x7F, 0x72, 0xBF, 0xFC, 0x95, 0xB6, 0x4A, 0x40, 0xE2, 0x5F, 0xED, 0xCF, + 0x17, 0xE8, 0x7F, 0xD5, 0x9E, 0x7D, 0x11, 0x61, 0x12, 0x3F, 0xF6, 0xFC, 0x5F, 0x67, 0x6F, 0xA5, + 0x8C, 0x04, 0x00, 0x40, 0x21, 0xC0, 0x08, 0x62, 0xF3, 0x5B, 0xC4, 0x2F, 0xFA, 0x74, 0x78, 0x7F, + 0x22, 0xB7, 0xC5, 0x69, 0x74, 0x21, 0x7F, 0x62, 0x59, 0xB3, 0xAF, 0xFF, 0xA7, 0xFF, 0xFE, 0x6F, + 0xDA, 0x04, 0x85, 0x23, 0x7F, 0xFF, 0x0C, 0xA8, 0x97, 0x9D, 0x07, 0x79, 0x78, 0x27, 0x8B, 0x3B, + 0x6A, 0x00, 0x03, 0x09, 0x03, 0xF0, 0x60, 0x41, 0x79, 0xFA, 0xDA, 0xA6, 0x78, 0x0B, 0x99, 0x14, + 0x18, 0x62, 0x91, 0x01, 0xA0, 0xF7, 0xC7, 0x16, 0x1D, 0x98, 0x0C, 0x7E, 0x16, 0x0D, 0x9A, 0xCC, + 0x5E, 0x64, 0xC1, 0xD9, 0x84, 0x01, 0x46, 0x10, 0x54, 0x9E, 0x6C, 0x5E, 0x63, 0x61, 0xF8, 0x08, + 0x44, 0x65, 0x32, 0x59, 0xAC, 0x82, 0xC3, 0xC0, 0x25, 0xDC, 0x28, 0x71, 0xB4, 0xDB, 0x23, 0x22, + 0x24, 0x2B, 0x60, 0x90, 0xF4, 0x74, 0x28, 0xEC, 0x06, 0x55, 0x97, 0x2D, 0xC0, 0x4A, 0xA3, 0xC6, + 0xC1, 0x46, 0x20, 0x42, 0x67, 0xC5, 0x62, 0xEB, 0x0E, 0xD5, 0x35, 0x46, 0x9D, 0x89, 0x7F, 0x2E, + 0x61, 0xE2, 0x36, 0x46, 0xE4, 0x79, 0xE3, 0xAE, 0xE2, 0xBE, 0x72, 0x63, 0x39, 0x62, 0xC2, 0x80, + 0xAC, 0x7E, 0xBF, 0x1C, 0xD8, 0xFA, 0x91, 0xA3, 0x5A, 0xEE, 0x71, 0x7C, 0x6D, 0x7C, 0xE9, 0x45, + 0x8D, 0x7F, 0xF2, 0x76, 0xA6, 0xF3, 0x42, 0xA9, 0x03, 0x7C, 0x43, 0x8B, 0xAC, 0xA7, 0x52, 0xD4, + 0x7B, 0xFE, 0x37, 0x31, 0x77, 0xB0, 0x0E, 0x00, 0x00, 0x2A, 0x02, 0x1F, 0xD0, 0x2E, 0x06, 0x94, + 0x1B, 0x37, 0xA9, 0xE0, 0xB8, 0xFF, 0xFB, 0x92, 0x64, 0x52, 0x0F, 0x04, 0xAF, 0x34, 0x49, 0x93, + 0x99, 0x7C, 0x40, 0x2F, 0x43, 0x49, 0x73, 0x28, 0x22, 0x84, 0x11, 0x68, 0xCB, 0x26, 0x0E, 0x69, + 0xAF, 0x40, 0xC7, 0x8E, 0x27, 0xB4, 0x32, 0xA5, 0x72, 0x1D, 0xF1, 0xDE, 0x41, 0x0B, 0x23, 0xE0, + 0x08, 0xE8, 0x77, 0xFC, 0x2B, 0x58, 0x75, 0x56, 0xED, 0x62, 0x3F, 0xC9, 0x14, 0xDE, 0x68, 0xAF, + 0xF8, 0xD0, 0x20, 0x85, 0xEA, 0x3A, 0x01, 0x44, 0x37, 0x03, 0x3A, 0x28, 0x72, 0x00, 0x17, 0xCE, + 0xA1, 0x41, 0x33, 0xF8, 0xF4, 0x1A, 0x12, 0x30, 0x98, 0xFC, 0xCE, 0xE5, 0x83, 0x8E, 0x11, 0xC9, + 0x54, 0x44, 0x84, 0xD3, 0x3A, 0x37, 0x4C, 0x34, 0x5F, 0x30, 0x19, 0x28, 0xD0, 0x29, 0x03, 0x96, + 0x22, 0x84, 0x98, 0x29, 0xEA, 0x3A, 0xB8, 0xD0, 0xC1, 0x0E, 0x48, 0x97, 0x08, 0x08, 0x17, 0x66, + 0x86, 0xCC, 0x95, 0x82, 0x00, 0x8E, 0x53, 0xAD, 0xB0, 0x0B, 0x45, 0x2D, 0x98, 0x8B, 0x22, 0x1B, + 0xBA, 0xEF, 0x0B, 0x0F, 0x48, 0xF4, 0x8F, 0x5F, 0xED, 0x05, 0x01, 0x73, 0x95, 0x68, 0x0B, 0x01, + 0xA9, 0x95, 0x45, 0xBB, 0x91, 0x4A, 0x60, 0xD8, 0xBC, 0x48, 0x0C, 0x2E, 0x9A, 0xE8, 0xA8, 0x7A, + 0x17, 0x86, 0x29, 0x54, 0xF2, 0x6B, 0x16, 0x6F, 0xA3, 0xA2, 0x8E, 0x70, 0x4C, 0x47, 0x9F, 0xC6, + 0x39, 0x09, 0x64, 0xD0, 0xC4, 0x3C, 0x5D, 0x42, 0x6A, 0x7A, 0xA0, 0x68, 0x3C, 0x7B, 0xFD, 0x6E, + 0x48, 0xD9, 0xA4, 0xB6, 0xC2, 0xC1, 0xC0, 0x90, 0x22, 0x86, 0x39, 0x45, 0xC0, 0x3E, 0x25, 0x04, + 0xE3, 0x67, 0x0B, 0xEA, 0x12, 0x7D, 0x94, 0x44, 0x57, 0xDF, 0xEF, 0x37, 0x47, 0x92, 0x0C, 0xAA, + 0x8C, 0x06, 0x22, 0x03, 0xC9, 0x9A, 0x03, 0x5F, 0xD3, 0xBB, 0x77, 0xF1, 0xBB, 0xFF, 0xEB, 0x54, + 0x73, 0x13, 0x0B, 0x97, 0x6A, 0x84, 0x24, 0xEA, 0x00, 0x03, 0x06, 0xE4, 0xD2, 0x44, 0x20, 0x11, + 0x85, 0xE4, 0x49, 0x9E, 0xA0, 0x90, 0x91, 0x32, 0x60, 0x70, 0x7E, 0x65, 0x35, 0x6E, 0x62, 0x11, + 0x26, 0x60, 0xB0, 0x92, 0x22, 0x1E, 0x4C, 0x14, 0x47, 0x0C, 0x31, 0x2D, 0x4C, 0x51, 0x0C, 0x0C, + 0xB1, 0x02, 0x0D, 0x1B, 0x43, 0xCC, 0x46, 0x09, 0x0C, 0x5B, 0x19, 0x0C, 0x18, 0x02, 0x8C, 0xC1, + 0x08, 0x4C, 0x15, 0x02, 0x00, 0xC0, 0x10, 0x8D, 0x49, 0xDB, 0x16, 0x9D, 0x89, 0xF0, 0x30, 0x00, + 0xA4, 0xC5, 0x85, 0xE2, 0xCE, 0x45, 0x90, 0x88, 0x03, 0xAC, 0x93, 0x50, 0x05, 0x8C, 0x2A, 0x31, + 0xC4, 0x62, 0xC9, 0xD0, 0xC9, 0x38, 0x93, 0x5C, 0x40, 0x0A, 0x0F, 0xCA, 0x0A, 0x08, 0x62, 0xF2, + 0xB9, 0x23, 0x30, 0x4C, 0x28, 0x44, 0xEB, 0xC2, 0x26, 0x95, 0xA7, 0x67, 0xA8, 0xA0, 0xF0, 0x27, + 0x34, 0x31, 0x1D, 0xE4, 0x52, 0xF8, 0x49, 0x7F, 0xFE, 0x19, 0xB0, 0xC4, 0xB0, 0xC1, 0xFF, 0xBC, + 0x15, 0x61, 0xB8, 0x8A, 0x6D, 0xBA, 0x08, 0x8C, 0xC9, 0x64, 0x19, 0x19, 0xFF, 0xD2, 0xC6, 0xE6, + 0x21, 0x41, 0xD5, 0xD3, 0x08, 0x80, 0x01, 0xFF, 0xFB, 0x92, 0x64, 0x4F, 0x8E, 0x04, 0xDF, 0x33, + 0x49, 0x13, 0xBA, 0x5C, 0x40, 0x2D, 0xA8, 0xF9, 0xFA, 0x08, 0x23, 0x9E, 0x91, 0x48, 0xCB, 0x24, + 0x2E, 0x65, 0x71, 0x10, 0xC3, 0x9F, 0x28, 0x28, 0x80, 0x8E, 0x7A, 0x05, 0x24, 0x28, 0x00, 0x8A, + 0xF5, 0x95, 0xA4, 0x7F, 0xD0, 0xC2, 0xDD, 0x95, 0x53, 0xC8, 0x00, 0x59, 0x3A, 0xF7, 0xFD, 0x7F, + 0xD2, 0x2D, 0xCD, 0xFF, 0xF3, 0x07, 0xEF, 0xBC, 0x1F, 0xFF, 0xFF, 0xCA, 0xED, 0xAC, 0x85, 0x22, + 0xEC, 0xA1, 0x7F, 0x28, 0xD8, 0x32, 0x49, 0x25, 0xA6, 0x04, 0x1D, 0x19, 0x8A, 0xB8, 0x66, 0xD1, + 0x81, 0x8D, 0xC4, 0xA6, 0x42, 0x44, 0x0D, 0x72, 0x40, 0x42, 0xB0, 0x51, 0x4C, 0xCC, 0x05, 0xD3, + 0x5A, 0xD4, 0x48, 0x51, 0x46, 0x41, 0x18, 0x1C, 0x58, 0x14, 0x7B, 0x4A, 0x30, 0x92, 0x70, 0xC3, + 0x43, 0x35, 0x05, 0x30, 0x59, 0x92, 0xB4, 0x70, 0x52, 0x90, 0x7F, 0x46, 0x08, 0x00, 0x22, 0xC9, + 0x06, 0x38, 0x81, 0x92, 0x5E, 0x21, 0x55, 0x26, 0x50, 0xC1, 0xAF, 0x02, 0xB2, 0x59, 0x48, 0x0B, + 0x24, 0x74, 0xCF, 0x0D, 0x45, 0x83, 0x8E, 0x40, 0xC0, 0x74, 0x31, 0x2A, 0x65, 0xB4, 0x59, 0xF8, + 0xE3, 0x51, 0x15, 0xAC, 0x5A, 0xC5, 0x9D, 0x6A, 0x1C, 0x69, 0x8F, 0xAF, 0x81, 0xDE, 0x33, 0x53, + 0x22, 0x08, 0x04, 0x22, 0x07, 0x5A, 0xFF, 0xFC, 0x96, 0x78, 0x8E, 0x3D, 0x88, 0x1B, 0xFC, 0xC4, + 0x9C, 0xE4, 0x41, 0x18, 0x4A, 0x3B, 0x16, 0x28, 0x1D, 0xB3, 0x85, 0x22, 0x77, 0x7F, 0xD1, 0xAB, + 0x00, 0x00, 0x42, 0x0A, 0x68, 0x58, 0x1C, 0x0F, 0x27, 0x95, 0x1F, 0xF1, 0x7F, 0xFF, 0x05, 0xC3, + 0xD4, 0xD3, 0x29, 0x0B, 0x88, 0xC3, 0x2D, 0x33, 0xAD, 0x11, 0xCC, 0xDB, 0xFF, 0xF6, 0xE6, 0x2F, + 0xCF, 0x93, 0xFF, 0xDE, 0x45, 0xFF, 0xFF, 0xF9, 0x68, 0x3D, 0xB5, 0x92, 0x90, 0x3B, 0xEB, 0xE9, + 0x5D, 0x84, 0x00, 0x00, 0x00, 0x50, 0x32, 0x58, 0x22, 0x03, 0x19, 0x08, 0x5C, 0x45, 0x20, 0xBC, + 0x87, 0x00, 0x1E, 0x16, 0x01, 0x00, 0x47, 0x10, 0x97, 0xB8, 0xD0, 0x1E, 0x1C, 0x14, 0x17, 0x18, + 0x44, 0x90, 0xC6, 0xE9, 0x1C, 0x00, 0x0E, 0x34, 0xF2, 0x8B, 0x30, 0x87, 0xA4, 0xE1, 0xF6, 0x22, + 0x4C, 0x4A, 0xC2, 0xA0, 0xE0, 0x97, 0xA6, 0x60, 0xC6, 0x86, 0x84, 0xE5, 0x99, 0xBD, 0x58, 0xF1, + 0x5A, 0x7E, 0x1F, 0x71, 0xA2, 0x31, 0x95, 0xFB, 0x43, 0x94, 0xE9, 0xDC, 0x79, 0x22, 0xBF, 0x95, + 0x22, 0xD2, 0x82, 0xE3, 0xC8, 0x49, 0x3C, 0xFE, 0x2B, 0x2C, 0xE7, 0x8D, 0x7F, 0x5E, 0xA5, 0xCE, + 0x64, 0x3F, 0x0B, 0x8C, 0xFF, 0xE7, 0xC7, 0x48, 0x3A, 0x74, 0x75, 0x4B, 0x7A, 0xED, 0x46, 0x63, + 0xFE, 0x9E, 0xBD, 0x7D, 0x1C, 0x82, 0x81, 0x00, 0x09, 0x08, 0x80, 0x84, 0x16, 0x85, 0x02, 0xC6, + 0xC5, 0x4E, 0x29, 0xFA, 0xDE, 0xF6, 0x40, 0xA3, 0x13, 0x0F, 0x9E, 0xAB, 0x72, 0xFF, 0x77, 0xFC, + 0xCE, 0x34, 0x36, 0x20, 0x2E, 0xDF, 0xFE, 0x93, 0xB0, 0xFF, 0xFB, 0x92, 0x64, 0x4C, 0x04, 0x03, + 0xA5, 0x32, 0xCE, 0x53, 0x4F, 0x3C, 0x44, 0x32, 0xC0, 0x4A, 0x1D, 0x05, 0x82, 0x00, 0x92, 0x44, + 0xCB, 0x28, 0x6E, 0x65, 0x6F, 0x40, 0xCB, 0x8A, 0xA6, 0x28, 0x30, 0x1D, 0x40, 0x21, 0x3A, 0xD0, + 0x70, 0x1F, 0x48, 0x38, 0x81, 0x45, 0x0B, 0x0B, 0x84, 0x1F, 0x88, 0xE2, 0xA0, 0x00, 0x00, 0x9A, + 0xD6, 0x8C, 0xB2, 0x23, 0x47, 0xC6, 0x0C, 0xA4, 0x06, 0x10, 0x83, 0x0C, 0x42, 0x72, 0x34, 0x2E, + 0x24, 0xC8, 0x62, 0x93, 0x4F, 0x92, 0x0C, 0x3C, 0x15, 0x35, 0x68, 0x88, 0xC1, 0xE5, 0xD0, 0x62, + 0x28, 0xCC, 0x81, 0xF3, 0x64, 0xB8, 0x8C, 0x10, 0x3A, 0x31, 0x60, 0xEC, 0xF2, 0x78, 0x28, 0xE8, + 0xF1, 0x2C, 0xB0, 0x45, 0x2C, 0x32, 0xA9, 0x91, 0x60, 0x61, 0xE4, 0x24, 0xAC, 0x36, 0xD4, 0x01, + 0x2B, 0x24, 0x70, 0x10, 0x10, 0x45, 0x9C, 0xD4, 0xD4, 0xC0, 0x88, 0x64, 0xB4, 0x41, 0xE2, 0xFA, + 0xB0, 0x45, 0x1F, 0x62, 0xA5, 0x81, 0xD0, 0x7A, 0x4A, 0xC4, 0x48, 0x45, 0x4E, 0x78, 0xBD, 0x64, + 0xEE, 0xCD, 0x94, 0xF9, 0xB4, 0x00, 0x9F, 0xCA, 0x14, 0x3A, 0xD9, 0x8F, 0x8F, 0xCA, 0x67, 0x48, + 0x42, 0x5E, 0x7F, 0xCC, 0x48, 0x7B, 0xDE, 0x54, 0xDA, 0x7B, 0xA4, 0xE8, 0xF2, 0x35, 0xFF, 0xE9, + 0xAC, 0x5D, 0x67, 0xC3, 0x83, 0x5C, 0x95, 0xDD, 0x51, 0x5B, 0xFF, 0xDB, 0xFF, 0xA6, 0xB0, 0x02, + 0x10, 0x00, 0x05, 0x03, 0x40, 0x28, 0x57, 0xA0, 0x8B, 0x47, 0xEB, 0x2A, 0x4D, 0x21, 0x43, 0x0A, + 0x9E, 0xE5, 0x34, 0xBA, 0x2E, 0xAF, 0x22, 0xC0, 0xF8, 0x2A, 0xF0, 0x30, 0xF2, 0xEE, 0x54, 0x35, + 0xEA, 0x7D, 0x2A, 0x7E, 0xBC, 0xC6, 0x39, 0xDF, 0xE8, 0x2B, 0x2E, 0x71, 0x82, 0xCA, 0x12, 0x81, + 0xB2, 0x4A, 0x00, 0x03, 0x08, 0x3A, 0x1E, 0x30, 0x28, 0x7C, 0xC1, 0xE2, 0x70, 0x55, 0x80, 0xC8, + 0x22, 0x13, 0x20, 0x9B, 0x8D, 0x69, 0xAE, 0x36, 0x48, 0x68, 0xCB, 0x41, 0x03, 0x03, 0x13, 0xCC, + 0xFC, 0x2A, 0x2F, 0x51, 0x82, 0x88, 0x86, 0x8A, 0x48, 0x09, 0xAF, 0x0C, 0xBC, 0x20, 0x31, 0x18, + 0xB4, 0xFA, 0xA8, 0x0A, 0x83, 0xE6, 0x9B, 0x80, 0x83, 0x4F, 0x8B, 0x94, 0xA9, 0xDB, 0x15, 0xA0, + 0x5A, 0x35, 0x2D, 0x6E, 0x82, 0x87, 0x2A, 0xA4, 0x91, 0x9C, 0x02, 0x97, 0x75, 0x9D, 0xA4, 0x7A, + 0x43, 0xE5, 0x6D, 0x5B, 0xB2, 0x10, 0x51, 0x29, 0xDA, 0xF6, 0xA5, 0xA9, 0x34, 0x90, 0x6B, 0xA2, + 0x33, 0x49, 0xD8, 0x83, 0x34, 0x83, 0x52, 0x1E, 0x14, 0x2B, 0x6F, 0x05, 0xED, 0x60, 0x65, 0xF4, + 0x14, 0x14, 0xD7, 0xFF, 0xEB, 0xB2, 0xE6, 0x9B, 0xFB, 0x0D, 0x35, 0x90, 0xA4, 0x0B, 0x95, 0x12, + 0x6F, 0x2A, 0x29, 0xCD, 0x4C, 0x2D, 0x1F, 0x83, 0xD5, 0xFE, 0x56, 0xC2, 0x3A, 0x69, 0xEB, 0x7A, + 0x92, 0x01, 0x00, 0x89, 0x2D, 0x83, 0x32, 0x13, 0x0F, 0x75, 0xC8, 0x41, 0x74, 0x5F, 0xD5, 0x9F, + 0xBA, 0x5B, 0x4D, 0xFC, 0xDA, 0xA5, 0x7E, 0xBF, 0x7F, 0xFB, 0x7D, 0xFF, 0xFB, 0x92, 0x64, 0x54, + 0x8E, 0x04, 0x68, 0x33, 0x49, 0x93, 0x99, 0x4B, 0xD0, 0x31, 0x08, 0x6A, 0x4C, 0x07, 0x02, 0x01, + 0x92, 0x18, 0xCD, 0x26, 0x4E, 0x69, 0x8F, 0x50, 0xCC, 0x9A, 0xA7, 0x68, 0x20, 0x8E, 0x3B, 0x7F, + 0x95, 0x69, 0xD1, 0x7F, 0xDA, 0x88, 0xED, 0xAD, 0xFF, 0xFC, 0xCC, 0x11, 0x91, 0xAE, 0xA5, 0x65, + 0x28, 0x99, 0x1B, 0x2A, 0x08, 0x24, 0xCA, 0xAC, 0x62, 0x22, 0x39, 0xA2, 0x4C, 0x66, 0xA2, 0x1D, + 0x99, 0x04, 0x00, 0x60, 0x52, 0x61, 0xBA, 0xF3, 0x46, 0x68, 0x20, 0x97, 0xEC, 0xCA, 0x22, 0x30, + 0x8B, 0x71, 0x9A, 0x80, 0x66, 0x41, 0x49, 0x1B, 0xC9, 0x02, 0x76, 0xF7, 0x19, 0x86, 0x49, 0x06, + 0x8C, 0x03, 0x17, 0xA0, 0x4F, 0x7B, 0x16, 0x10, 0x0A, 0x32, 0x44, 0x06, 0xD4, 0xB1, 0x54, 0x53, + 0x1D, 0x08, 0x89, 0x70, 0xB6, 0x8D, 0x38, 0x5F, 0xD7, 0x1D, 0x1B, 0x81, 0x80, 0xDA, 0xAB, 0x27, + 0x15, 0x16, 0x9C, 0xE8, 0xBC, 0xD9, 0x9E, 0x82, 0xE3, 0x4B, 0xE9, 0x21, 0xB7, 0x25, 0x90, 0xBA, + 0xA1, 0x62, 0xE2, 0xDD, 0x5D, 0x15, 0x73, 0x07, 0x57, 0x0D, 0x38, 0x50, 0x8F, 0x87, 0x00, 0x29, + 0x13, 0x14, 0xC9, 0x99, 0x9D, 0x6A, 0xD0, 0xEF, 0xAD, 0xDF, 0xB5, 0xF5, 0xBA, 0x41, 0x11, 0xE3, + 0x6E, 0xD3, 0xD2, 0x17, 0xFE, 0x74, 0x82, 0xFC, 0xB8, 0xDC, 0x27, 0xBF, 0xC8, 0x61, 0x10, 0x99, + 0x73, 0x6E, 0x14, 0x40, 0x9A, 0xA0, 0xC1, 0x00, 0x01, 0x46, 0x40, 0x14, 0x04, 0x80, 0x54, 0x1C, + 0x35, 0x26, 0xFA, 0x6A, 0x53, 0x52, 0x37, 0x97, 0x3C, 0x3D, 0xFC, 0x9F, 0xFF, 0xCE, 0x65, 0xE4, + 0x66, 0x8F, 0xA2, 0x14, 0xBF, 0xFE, 0x52, 0xAC, 0x66, 0xE1, 0x64, 0xA1, 0xFD, 0x97, 0x11, 0x9F, + 0x54, 0xA1, 0x2A, 0x9C, 0x8B, 0x8E, 0x75, 0xB9, 0x00, 0x02, 0x08, 0x65, 0x0E, 0x42, 0x81, 0x23, + 0x37, 0x4B, 0x4C, 0x74, 0x49, 0x31, 0xA0, 0x20, 0xAC, 0xA4, 0x61, 0xFC, 0xC9, 0x87, 0xCD, 0xE4, + 0xC0, 0x13, 0x07, 0x01, 0xCD, 0x34, 0x4F, 0x30, 0xF8, 0xB8, 0x80, 0x4A, 0x6B, 0x92, 0x88, 0x31, + 0x88, 0x61, 0x70, 0x79, 0x86, 0x48, 0xC7, 0x19, 0x66, 0x91, 0x0A, 0x02, 0x2A, 0xB9, 0xA9, 0x40, + 0x34, 0xB5, 0x46, 0x45, 0x1A, 0x43, 0x0A, 0x05, 0x20, 0x6B, 0x83, 0xA2, 0x31, 0x15, 0x5D, 0x2C, + 0x00, 0x30, 0x99, 0x30, 0xA1, 0x10, 0x24, 0xC5, 0x24, 0xD3, 0xF7, 0x9B, 0x03, 0xB7, 0x84, 0x75, + 0xDA, 0x4D, 0x39, 0x63, 0x1B, 0x17, 0x85, 0xF9, 0x81, 0x14, 0xFF, 0x85, 0x78, 0x55, 0x79, 0x0E, + 0x19, 0x02, 0x62, 0x87, 0x8C, 0xFE, 0xB9, 0xA9, 0xA9, 0xBD, 0xAC, 0xA7, 0x49, 0xED, 0x02, 0xF3, + 0x6D, 0x86, 0xF0, 0x44, 0xA2, 0x1F, 0xC7, 0x71, 0x1E, 0x5C, 0x7C, 0xE9, 0x2F, 0xF2, 0xE2, 0x97, + 0x22, 0x55, 0x72, 0xE0, 0x11, 0x70, 0x87, 0x00, 0x00, 0x00, 0x87, 0x80, 0x24, 0x1C, 0xC6, 0x47, + 0x5A, 0x65, 0xFB, 0x57, 0x21, 0x23, 0x17, 0x06, 0x17, 0x79, 0xA8, 0xC3, 0x81, 0xFF, 0xFB, 0x92, + 0x64, 0x52, 0x8F, 0x44, 0x6C, 0x33, 0x4A, 0x13, 0x99, 0x5B, 0xD4, 0x30, 0xC1, 0xE9, 0x7A, 0x05, + 0x22, 0x20, 0x11, 0x58, 0xD3, 0x24, 0x0E, 0x65, 0xF1, 0x00, 0xBF, 0x0D, 0x26, 0xB4, 0x10, 0x09, + 0x08, 0x84, 0xB2, 0x27, 0x7F, 0x63, 0x4F, 0x4E, 0xB2, 0x1A, 0xBF, 0x77, 0xF5, 0x3E, 0x58, 0xF7, + 0x7A, 0xCF, 0x0B, 0x08, 0x41, 0xA8, 0x04, 0x5A, 0x65, 0x43, 0x23, 0xEE, 0xC1, 0x8C, 0x42, 0xA6, + 0xF7, 0x3B, 0x98, 0xAC, 0x46, 0x67, 0x80, 0x40, 0xF1, 0x08, 0xEE, 0x40, 0x73, 0x4D, 0x83, 0x4D, + 0x86, 0x7D, 0x06, 0x84, 0x0D, 0x27, 0x08, 0x05, 0x1F, 0x4C, 0x02, 0x4F, 0x31, 0xB1, 0xF4, 0x12, + 0xDF, 0x1A, 0x17, 0x18, 0xBC, 0xBA, 0x09, 0x0E, 0x04, 0x33, 0x56, 0x71, 0x00, 0x3C, 0xD3, 0x48, + 0x17, 0xDB, 0xAA, 0xFC, 0x85, 0x49, 0x1A, 0x71, 0x00, 0x89, 0x46, 0x14, 0x98, 0x90, 0x27, 0xCE, + 0x80, 0xC5, 0x4D, 0x0F, 0x4A, 0x03, 0x64, 0x00, 0x6F, 0x80, 0x4A, 0x47, 0x1F, 0x51, 0x00, 0x54, + 0xF7, 0xE1, 0x84, 0xB1, 0x11, 0x0B, 0x1F, 0x41, 0xB0, 0x61, 0x93, 0x10, 0xF7, 0x6C, 0x8A, 0xF6, + 0x69, 0x6E, 0x86, 0x96, 0x47, 0x8C, 0x46, 0x27, 0x7F, 0xFF, 0xFF, 0xF5, 0x8D, 0x5C, 0xEA, 0x2B, + 0x7C, 0x0D, 0xF9, 0x59, 0xAA, 0x88, 0x9A, 0x8A, 0xF5, 0xD1, 0x74, 0x69, 0xDE, 0x8E, 0xC6, 0x9A, + 0xDD, 0x0F, 0x9F, 0x0E, 0x1A, 0x2E, 0x2E, 0x00, 0x09, 0x83, 0x80, 0x0D, 0xE6, 0xA8, 0x18, 0x19, + 0x43, 0x35, 0xC4, 0xB9, 0x72, 0x90, 0x18, 0x64, 0x62, 0xED, 0x56, 0x52, 0xB6, 0xF6, 0x46, 0x10, + 0x9E, 0xA0, 0x44, 0x97, 0xCE, 0x87, 0x99, 0xAA, 0xCF, 0xBB, 0xFA, 0xD0, 0x5A, 0x10, 0x22, 0xC3, + 0x83, 0x8B, 0x05, 0x14, 0x35, 0x01, 0x30, 0x4E, 0xF1, 0xA0, 0x90, 0xD4, 0x82, 0xA0, 0xC2, 0x11, + 0x28, 0x60, 0x13, 0x31, 0x64, 0xC4, 0x32, 0x06, 0x72, 0x32, 0x1C, 0x3C, 0x32, 0x28, 0xBC, 0x0B, + 0x83, 0x26, 0x23, 0x22, 0xA6, 0x9E, 0xF6, 0x67, 0x23, 0xE6, 0xE4, 0xAC, 0x79, 0x1A, 0x42, 0xA2, + 0x01, 0xC1, 0x00, 0x50, 0xF1, 0xAD, 0x80, 0x81, 0x12, 0xFF, 0x86, 0x1E, 0x93, 0x73, 0x95, 0x83, + 0x96, 0x89, 0x6C, 0x88, 0x01, 0x49, 0x83, 0x18, 0x61, 0x80, 0x91, 0x03, 0x87, 0x1C, 0xC8, 0xE1, + 0x87, 0x01, 0x84, 0x05, 0xBD, 0xC5, 0x50, 0x23, 0x12, 0x05, 0x1C, 0x07, 0xB8, 0x91, 0xE5, 0xB5, + 0x87, 0x24, 0x43, 0x28, 0xD3, 0x53, 0x2A, 0x84, 0x2C, 0x4C, 0x55, 0x94, 0x7C, 0xA8, 0x0A, 0xDA, + 0x6F, 0xC8, 0x6F, 0xBD, 0x51, 0xA1, 0x29, 0xFA, 0xFF, 0xFF, 0xFF, 0xE6, 0x9F, 0xE2, 0x68, 0x10, + 0x37, 0xB8, 0x31, 0x34, 0x87, 0xB4, 0x29, 0x4D, 0xB6, 0x23, 0x7E, 0x16, 0xF0, 0xE3, 0x3E, 0xB5, + 0x32, 0xAC, 0x62, 0x9A, 0x7B, 0xFE, 0x94, 0x7B, 0x15, 0xC6, 0x80, 0x70, 0x00, 0x00, 0x08, 0x2C, + 0x05, 0x0A, 0xFF, 0x01, 0x56, 0x45, 0xB5, 0x61, 0x14, 0xC5, 0x23, 0x7F, 0x17, 0x34, 0x5F, 0xFF, + 0xFB, 0x92, 0x64, 0x55, 0x0F, 0x44, 0xA9, 0x34, 0xC8, 0x8B, 0xBB, 0x7A, 0xE4, 0x31, 0x43, 0x39, + 0x9A, 0x00, 0xA6, 0x36, 0x0F, 0xC8, 0xCF, 0x26, 0x0E, 0x69, 0x2B, 0xD0, 0xC0, 0x8B, 0xE5, 0xA8, + 0x23, 0x0D, 0xC8, 0x29, 0xCD, 0x3B, 0x59, 0x3C, 0xEE, 0x76, 0xE3, 0x2C, 0x26, 0x15, 0x75, 0x53, + 0xDF, 0xAD, 0x3F, 0x76, 0xB6, 0xFF, 0xD1, 0x69, 0xB0, 0x51, 0x49, 0x34, 0x59, 0x25, 0x42, 0xF0, + 0xD2, 0xD1, 0x2C, 0x03, 0x0C, 0x5A, 0x58, 0x02, 0x01, 0x06, 0x00, 0x85, 0xAF, 0x36, 0x1C, 0xC4, + 0xC8, 0x45, 0x03, 0x20, 0x84, 0xD8, 0xC9, 0xAA, 0x4B, 0xC6, 0x70, 0x29, 0xAC, 0x84, 0x67, 0xE4, + 0x1D, 0x52, 0x06, 0x31, 0x41, 0x99, 0x8E, 0x08, 0x10, 0x42, 0x94, 0x12, 0x80, 0x68, 0x32, 0x4C, + 0x00, 0x9B, 0x2B, 0xB5, 0xC8, 0xEF, 0x22, 0x95, 0x65, 0xE4, 0xDD, 0xC1, 0x4F, 0x60, 0x59, 0x21, + 0x81, 0x1C, 0x89, 0x73, 0xAB, 0x28, 0x40, 0x05, 0x1A, 0xB2, 0x84, 0x34, 0x2A, 0x2D, 0x29, 0xD3, + 0xAF, 0x39, 0x2C, 0x51, 0xF0, 0x20, 0xA6, 0x9F, 0xEA, 0x3E, 0xF9, 0x11, 0x3F, 0x3D, 0x50, 0x04, + 0x5A, 0x60, 0x7B, 0xBF, 0x49, 0x02, 0x4C, 0x7F, 0xFF, 0xFF, 0x53, 0x47, 0x9A, 0x8E, 0x36, 0xA9, + 0x19, 0xA2, 0x57, 0xB7, 0xB9, 0x3C, 0x6B, 0x08, 0xCB, 0x95, 0x1B, 0x0F, 0xFF, 0x40, 0x06, 0x00, + 0x00, 0x02, 0x30, 0xE4, 0x6E, 0x77, 0xB8, 0x6F, 0xDD, 0x8A, 0x84, 0x42, 0x66, 0x65, 0xC8, 0xC2, + 0xC1, 0x65, 0xE5, 0x41, 0xE5, 0x2A, 0xDC, 0x84, 0x15, 0x07, 0xC3, 0xE1, 0xEF, 0xBB, 0xF7, 0xFD, + 0xDD, 0x47, 0xBF, 0xE6, 0x56, 0x02, 0x1E, 0x20, 0x48, 0x65, 0x5A, 0x3B, 0xBE, 0x7D, 0x01, 0xB3, + 0x89, 0x0C, 0x0A, 0xC2, 0xF6, 0x63, 0x50, 0x09, 0x82, 0x02, 0x21, 0x70, 0x49, 0xB1, 0x25, 0xE6, + 0x51, 0x31, 0x99, 0x6C, 0xCE, 0x60, 0x32, 0x29, 0xB4, 0x87, 0x26, 0x01, 0x2A, 0x18, 0xF4, 0xD0, + 0x6A, 0x34, 0x79, 0xED, 0xDA, 0x06, 0x18, 0x63, 0x70, 0x1C, 0x79, 0x07, 0xD5, 0x61, 0x7D, 0x82, + 0x81, 0x4B, 0x9A, 0x74, 0x82, 0x43, 0xCA, 0xD0, 0x54, 0x00, 0xFA, 0x60, 0xA3, 0x64, 0x80, 0x48, + 0x40, 0xBC, 0xD6, 0x0B, 0x6A, 0xB0, 0xE8, 0x88, 0xE6, 0x01, 0x84, 0x86, 0x33, 0xA8, 0xC8, 0x14, + 0xE2, 0x82, 0xCA, 0x8E, 0x34, 0xF5, 0x2F, 0x77, 0x19, 0x69, 0x6E, 0xD9, 0x75, 0xB8, 0x09, 0x9B, + 0xCB, 0xEF, 0xE5, 0x01, 0xD3, 0x02, 0x25, 0xFF, 0xE9, 0x12, 0xD5, 0xFD, 0xFD, 0x25, 0x76, 0x39, + 0x02, 0x4E, 0xA5, 0xA0, 0xC1, 0x2F, 0x44, 0xBB, 0x48, 0xE6, 0x9A, 0x06, 0xF8, 0xA5, 0xC1, 0xAD, + 0x37, 0xFD, 0x6A, 0xFD, 0x57, 0x75, 0x7F, 0x9A, 0x63, 0x08, 0x01, 0xA8, 0x20, 0x00, 0x8B, 0x7F, + 0x04, 0x85, 0x2D, 0x06, 0x79, 0x16, 0xFD, 0x31, 0x52, 0x02, 0xE0, 0x64, 0x22, 0x50, 0xFB, 0x9A, + 0x18, 0xDE, 0x4E, 0x2B, 0xC6, 0x8B, 0xEF, 0xF9, 0x8A, 0x97, 0x74, 0x7D, 0xFE, 0x8F, 0x3C, 0x60, + 0xD2, 0xFF, 0xFB, 0x92, 0x64, 0x59, 0x8E, 0x04, 0x55, 0x34, 0x49, 0x0B, 0x9A, 0x4B, 0x64, 0x32, + 0x21, 0x59, 0xBD, 0x18, 0x22, 0x00, 0x10, 0x38, 0xD3, 0x26, 0x4D, 0xE1, 0x2F, 0x40, 0xCE, 0x8D, + 0xA5, 0xCC, 0x14, 0x8C, 0x38, 0x29, 0xCC, 0x90, 0x17, 0x75, 0x66, 0x59, 0x73, 0xF4, 0x28, 0x30, + 0x86, 0x5C, 0x23, 0x10, 0x2C, 0x31, 0x98, 0xF0, 0x7F, 0x28, 0x20, 0x44, 0x0B, 0x10, 0x6D, 0x9B, + 0x83, 0x4E, 0x66, 0x8A, 0xE4, 0x0A, 0x39, 0x33, 0xF8, 0x04, 0xB3, 0x33, 0xE7, 0xE3, 0x35, 0x0A, + 0x31, 0x04, 0x81, 0x01, 0x69, 0x28, 0x19, 0xC8, 0xEA, 0x2E, 0x87, 0x80, 0x18, 0x85, 0x60, 0x82, + 0x1E, 0x22, 0xBA, 0x89, 0x8E, 0x82, 0x42, 0xA1, 0x83, 0x03, 0x4C, 0x89, 0x1B, 0x44, 0x4C, 0xC0, + 0x54, 0x59, 0x2A, 0xF7, 0x61, 0x04, 0x24, 0x94, 0x33, 0xD4, 0x02, 0x2C, 0x0C, 0xFB, 0x0A, 0x62, + 0x0A, 0xA7, 0x55, 0x09, 0xCA, 0x5D, 0x03, 0x71, 0x7E, 0x36, 0xD5, 0x73, 0xF7, 0x30, 0x67, 0x09, + 0x04, 0x9F, 0xFA, 0xD0, 0x71, 0x8A, 0x8F, 0xF4, 0x6D, 0xFD, 0x2C, 0x43, 0xCF, 0x41, 0x33, 0x88, + 0x18, 0xC8, 0xF6, 0xDD, 0x93, 0xF6, 0x88, 0x99, 0x07, 0x6F, 0x7F, 0xDD, 0x5B, 0x85, 0x52, 0xAE, + 0x90, 0x00, 0x21, 0xC0, 0x0E, 0x4F, 0x51, 0x58, 0x1C, 0x0F, 0x89, 0xC8, 0x84, 0x88, 0x1C, 0x93, + 0x08, 0xE4, 0xC7, 0x24, 0x8A, 0x45, 0xD3, 0x53, 0x35, 0x5B, 0xB0, 0xC8, 0x80, 0xB4, 0x11, 0x59, + 0xBE, 0x4E, 0x37, 0x83, 0xF5, 0xF6, 0x0E, 0x88, 0xDF, 0xB9, 0x2C, 0xED, 0x55, 0x14, 0x69, 0xCB, + 0xA7, 0xF3, 0xA0, 0x65, 0x2A, 0x01, 0x1F, 0x56, 0xB4, 0x01, 0x20, 0x36, 0x4B, 0xD3, 0xC8, 0x17, + 0x25, 0x08, 0x3A, 0x28, 0x13, 0x5B, 0x11, 0x11, 0x16, 0x9B, 0x44, 0x08, 0x58, 0x50, 0xA8, 0xBE, + 0x38, 0x5A, 0x63, 0x95, 0x46, 0x6E, 0xBA, 0x61, 0xDC, 0xA0, 0xD3, 0x70, 0x48, 0xF9, 0xA5, 0xA3, + 0x80, 0x85, 0x0B, 0x52, 0x06, 0x05, 0x2C, 0x70, 0x4F, 0x3C, 0x80, 0xBC, 0x09, 0xCA, 0x97, 0x6D, + 0xA8, 0x5C, 0x04, 0xBA, 0x53, 0x7A, 0xB0, 0xF0, 0xA8, 0xAB, 0x61, 0xAB, 0x82, 0x01, 0x4C, 0x35, + 0x85, 0x6A, 0x0A, 0x04, 0x95, 0xCC, 0x09, 0xE6, 0x86, 0x91, 0xB3, 0x56, 0xD5, 0x44, 0x8F, 0x2B, + 0x13, 0x4A, 0x5C, 0xE4, 0x01, 0xF1, 0xEC, 0x87, 0x1F, 0x34, 0x5A, 0xD1, 0xB9, 0xF5, 0xFE, 0xE4, + 0xE0, 0x8F, 0xFF, 0xEA, 0x13, 0x5D, 0x9F, 0x83, 0xC6, 0xE4, 0xFA, 0x84, 0x88, 0xD6, 0x77, 0x4B, + 0xD1, 0xB3, 0x43, 0xC6, 0xFF, 0xEC, 0x65, 0x1C, 0xCA, 0x00, 0x00, 0x40, 0x04, 0xDD, 0xE0, 0x4E, + 0x26, 0xF0, 0x40, 0x74, 0x64, 0x34, 0x35, 0xB3, 0x65, 0xA4, 0x23, 0x12, 0x56, 0x59, 0xA2, 0x1C, + 0x4C, 0x96, 0xD6, 0xE0, 0xD1, 0xF0, 0x9A, 0x0B, 0x63, 0xAA, 0xA1, 0x5F, 0x76, 0xBE, 0x8F, 0x40, + 0x9F, 0x47, 0xEF, 0x32, 0x2B, 0xA4, 0xA1, 0xB0, 0xB3, 0x4E, 0x87, 0x82, 0x0B, 0xAD, 0xE0, 0x8C, + 0x38, 0x69, 0x7F, 0xFF, 0xFB, 0x92, 0x64, 0x5F, 0x0E, 0x84, 0x1D, 0x33, 0xC9, 0x0B, 0x79, 0x5C, + 0x44, 0x32, 0xA1, 0x99, 0xCA, 0x05, 0x22, 0x0C, 0x0F, 0xE0, 0xBB, 0x26, 0x4E, 0x69, 0x4B, 0xD0, + 0xD3, 0x05, 0x26, 0x4C, 0x03, 0x30, 0x08, 0x19, 0x83, 0x81, 0x62, 0x10, 0xC1, 0x99, 0x57, 0xA7, + 0x12, 0x7E, 0x99, 0x34, 0x6E, 0x69, 0x13, 0x71, 0x98, 0xC3, 0xA3, 0xA3, 0xE0, 0x23, 0x02, 0x1E, + 0x47, 0x78, 0xE9, 0x9D, 0x98, 0x6A, 0xC5, 0x9B, 0xA9, 0xA6, 0x00, 0xE2, 0x8E, 0xA3, 0xAA, 0x43, + 0x8C, 0x24, 0x03, 0x02, 0x2F, 0x3B, 0x76, 0x4F, 0x76, 0x83, 0x84, 0x36, 0x40, 0x11, 0x7E, 0xB8, + 0xE3, 0x20, 0x5B, 0x1A, 0x5B, 0xC2, 0xDF, 0x44, 0x2D, 0x81, 0x9B, 0xD7, 0x51, 0x80, 0xBC, 0x12, + 0x2A, 0x8A, 0xAE, 0xFC, 0xAD, 0x07, 0x78, 0xBF, 0xCF, 0x2D, 0xC4, 0x7C, 0x8A, 0x90, 0x8A, 0xE0, + 0x38, 0x1A, 0xAF, 0x43, 0xBE, 0x84, 0xC6, 0xDB, 0x3C, 0xD9, 0xCD, 0xF6, 0x05, 0xD3, 0x88, 0xC6, + 0x62, 0x6B, 0x40, 0x35, 0x91, 0xFF, 0x26, 0x76, 0x3D, 0x81, 0x86, 0xA8, 0x3A, 0xAB, 0x80, 0x02, + 0x3B, 0x80, 0xC0, 0x8E, 0x70, 0x7C, 0x41, 0x30, 0x26, 0xB3, 0x4A, 0xC6, 0xC6, 0xD1, 0xE7, 0x17, + 0x30, 0x60, 0xE2, 0xF7, 0x25, 0x66, 0x10, 0xD5, 0x94, 0x53, 0xC4, 0xC9, 0x59, 0xEF, 0xE9, 0x73, + 0x5A, 0x4F, 0x9F, 0xFC, 0x80, 0x85, 0x04, 0x09, 0x91, 0xB9, 0x20, 0x9A, 0xD4, 0x80, 0x3A, 0x52, + 0x8B, 0x8B, 0x9B, 0x00, 0x03, 0x8B, 0x6B, 0x00, 0x60, 0xD2, 0xC9, 0x9B, 0xC8, 0x86, 0x55, 0x04, + 0x98, 0x24, 0x02, 0x62, 0x01, 0xB1, 0xB1, 0xAD, 0xC6, 0x35, 0x01, 0x19, 0x01, 0x02, 0x1C, 0x74, + 0x11, 0x11, 0x4E, 0x0B, 0x53, 0x20, 0x28, 0xFA, 0xBE, 0x3C, 0x77, 0x0B, 0x86, 0x5D, 0xD3, 0x0E, + 0x60, 0xC1, 0x95, 0x30, 0x02, 0x4A, 0xA1, 0x42, 0xCC, 0x95, 0x7B, 0x30, 0x52, 0xD0, 0xB0, 0xB1, + 0xE0, 0x76, 0x9D, 0xC4, 0xA8, 0x2B, 0x0C, 0xD4, 0xD9, 0xAA, 0x7C, 0x30, 0xD7, 0xD5, 0x4C, 0x89, + 0x92, 0x44, 0xE4, 0x70, 0x97, 0xE5, 0xD8, 0x68, 0x7D, 0x60, 0x94, 0x0F, 0xAA, 0x42, 0xAE, 0xA4, + 0xF0, 0xB4, 0xEF, 0x33, 0x41, 0xD2, 0x4B, 0x04, 0x92, 0x6A, 0x6B, 0xEC, 0x4C, 0xF9, 0x2F, 0xF7, + 0xDF, 0xC5, 0x6F, 0xBF, 0xFE, 0x6F, 0xF1, 0xE8, 0x77, 0xD8, 0xA2, 0x58, 0xC8, 0x59, 0x6F, 0xCD, + 0x3F, 0xEC, 0xB2, 0xF5, 0x33, 0xC7, 0x7A, 0x7B, 0xE0, 0x80, 0x00, 0x53, 0x7D, 0x11, 0x30, 0x7C, + 0x25, 0x56, 0xF9, 0xF2, 0x54, 0xEB, 0xFC, 0x3B, 0x72, 0x36, 0x61, 0x39, 0xBF, 0xCA, 0xA6, 0xBF, + 0xD7, 0xF9, 0x82, 0xA5, 0xB7, 0xFF, 0xFF, 0x7E, 0xC3, 0xD7, 0xA3, 0x5E, 0x44, 0xA5, 0x1E, 0xB0, + 0x85, 0x1C, 0x09, 0x98, 0xB2, 0x51, 0xF5, 0xE5, 0xFB, 0x18, 0x1F, 0x50, 0xA8, 0x0C, 0xC2, 0xC0, + 0xD3, 0xEA, 0x14, 0x0C, 0xD4, 0x14, 0x30, 0xE8, 0x18, 0xCD, 0x4B, 0xC3, 0x39, 0x9B, 0x4C, 0x52, + 0x80, 0x07, 0x30, 0xD7, 0x49, 0xFF, 0xFB, 0x92, 0x64, 0x69, 0x0E, 0x04, 0x2A, 0x32, 0xC9, 0x93, + 0x9A, 0x5A, 0xF0, 0x30, 0xC8, 0x09, 0xB7, 0x0C, 0x23, 0x9E, 0x51, 0xC8, 0xCB, 0x22, 0x4E, 0x69, + 0x6F, 0x40, 0xCD, 0x84, 0xA6, 0x8C, 0x14, 0x08, 0x10, 0xA0, 0xC0, 0x09, 0xBC, 0x60, 0xA3, 0x39, + 0xA6, 0x19, 0x66, 0x87, 0x06, 0x03, 0x05, 0xC6, 0x6E, 0x1B, 0x00, 0xA9, 0x82, 0xD9, 0x91, 0x13, + 0x59, 0xC6, 0x43, 0x21, 0xF5, 0x26, 0x10, 0x05, 0x18, 0x59, 0x08, 0xF0, 0x27, 0xF9, 0x8C, 0x03, + 0x8F, 0x2B, 0xD4, 0x92, 0x54, 0x63, 0x02, 0x9E, 0x9A, 0xE8, 0xF2, 0x15, 0x1F, 0x28, 0x6C, 0x35, + 0xAA, 0xCD, 0xB2, 0x88, 0x21, 0x82, 0xED, 0xA9, 0x8C, 0x09, 0x11, 0x81, 0x22, 0x0B, 0x72, 0x34, + 0xB5, 0x4B, 0x8D, 0xC9, 0x46, 0xC5, 0x22, 0xD2, 0x41, 0x51, 0x2C, 0x66, 0x48, 0xFC, 0x91, 0x7F, + 0x0B, 0x68, 0xAF, 0xFF, 0xE6, 0x55, 0xC8, 0xE8, 0x59, 0x35, 0x10, 0x23, 0x18, 0x30, 0x79, 0x7D, + 0xA8, 0x3C, 0xB2, 0x4B, 0xD2, 0xBF, 0x17, 0x5B, 0x28, 0xBB, 0xFB, 0x80, 0x04, 0x9D, 0xB0, 0xBB, + 0x66, 0x18, 0x15, 0xE8, 0x20, 0x01, 0xB0, 0x4C, 0x31, 0xEB, 0x8A, 0x07, 0x16, 0x4C, 0x18, 0x14, + 0x20, 0x08, 0x52, 0xAA, 0x34, 0x33, 0xEB, 0xFF, 0x5F, 0xCD, 0x1F, 0x58, 0xD7, 0x11, 0x36, 0x59, + 0xC7, 0x4F, 0x98, 0x15, 0x08, 0x9D, 0x3A, 0xF5, 0xDA, 0xCF, 0xC9, 0x27, 0xAE, 0x40, 0x9D, 0x00, + 0x03, 0x09, 0x74, 0x54, 0x94, 0x78, 0x71, 0xDA, 0x99, 0x96, 0x02, 0xC0, 0xE3, 0xE1, 0x9F, 0x4B, + 0xC6, 0x33, 0xB1, 0x9A, 0x10, 0xA8, 0x21, 0x1C, 0xAC, 0xB3, 0x4C, 0x10, 0x40, 0x49, 0x93, 0x19, + 0x09, 0x83, 0x2D, 0x46, 0xF3, 0x20, 0x19, 0x61, 0x84, 0x0A, 0x42, 0xBC, 0x15, 0x99, 0x33, 0x95, + 0x19, 0x8F, 0x48, 0x66, 0xC5, 0x04, 0x0A, 0x59, 0xB0, 0x60, 0xD0, 0xF4, 0xF4, 0x58, 0x14, 0x31, + 0x70, 0x18, 0x0A, 0x8E, 0xA2, 0xB2, 0xF5, 0x7F, 0x9E, 0x87, 0xA8, 0x80, 0x0B, 0x25, 0x76, 0xE6, + 0xEB, 0xC4, 0x68, 0xD5, 0xFC, 0x36, 0x93, 0x0A, 0x5E, 0x34, 0x01, 0x7E, 0xEA, 0x5B, 0x3E, 0xA0, + 0x4C, 0x37, 0x13, 0x97, 0x00, 0xB0, 0x48, 0x4A, 0x12, 0x9F, 0x92, 0xEA, 0xDB, 0xFD, 0x09, 0xE8, + 0x70, 0xD8, 0x26, 0x1F, 0x1D, 0x2C, 0x50, 0x90, 0x8A, 0x7C, 0xE1, 0x29, 0xFF, 0xFA, 0xBF, 0xC5, + 0xB0, 0x00, 0x00, 0x00, 0x38, 0xAE, 0xE1, 0xC4, 0x3D, 0x50, 0xFF, 0xE5, 0x18, 0x2F, 0xFD, 0x29, + 0xAB, 0xB0, 0x20, 0x0C, 0x07, 0xC5, 0x42, 0xCF, 0x61, 0xE8, 0xB1, 0xF3, 0xCA, 0x38, 0x38, 0x0B, + 0xF7, 0x77, 0x49, 0xFE, 0xDF, 0xA0, 0xA7, 0xB5, 0xBA, 0x8D, 0xDE, 0x2F, 0x4B, 0x5E, 0x85, 0x5D, + 0x89, 0xF0, 0xEF, 0x4A, 0x56, 0x00, 0x96, 0x15, 0xE5, 0x05, 0x82, 0x33, 0xBA, 0x58, 0x52, 0x00, + 0x20, 0x73, 0x8A, 0x1C, 0x3B, 0x04, 0xB0, 0x09, 0xD3, 0xDB, 0x08, 0xC4, 0x0C, 0x34, 0xEB, 0x0C, + 0xD9, 0xF3, 0x0F, 0x54, 0xF8, 0x11, 0x06, 0xFF, 0xFB, 0x92, 0x64, 0x6C, 0x0C, 0x04, 0x0A, 0x33, + 0x49, 0x93, 0x9A, 0x3B, 0x60, 0x34, 0xA1, 0x39, 0xCA, 0x18, 0x29, 0x00, 0x0D, 0x94, 0x81, 0x2A, + 0x4D, 0xEB, 0x06, 0xC0, 0xCA, 0x13, 0x28, 0xE4, 0x10, 0x0F, 0x0E, 0x5F, 0x2B, 0x08, 0xD6, 0x01, + 0x91, 0x13, 0x60, 0x84, 0x11, 0xD1, 0x03, 0x12, 0x26, 0x0B, 0x6F, 0x16, 0xC2, 0xEA, 0x86, 0xDB, + 0x8B, 0x59, 0x5D, 0x0B, 0x29, 0xED, 0x4A, 0x96, 0x53, 0x23, 0x94, 0x8F, 0x2A, 0x5F, 0x05, 0x43, + 0xAF, 0x3F, 0x60, 0x88, 0x25, 0x83, 0x75, 0xD6, 0x63, 0xE5, 0xE1, 0x79, 0x3D, 0xFD, 0xC3, 0x39, + 0x4C, 0x1F, 0x9D, 0xD6, 0x72, 0xF2, 0xD5, 0x82, 0xCF, 0xD7, 0x2A, 0xE2, 0x3F, 0x7A, 0x25, 0x83, + 0xAB, 0x3B, 0xFF, 0xF6, 0xAA, 0x98, 0x10, 0x02, 0x84, 0x3E, 0xA2, 0x4F, 0x27, 0x93, 0x79, 0xE7, + 0x46, 0x69, 0x1F, 0xD7, 0xE6, 0x14, 0x79, 0xD2, 0x8E, 0x5A, 0x10, 0xF4, 0x73, 0x0B, 0x3C, 0x46, + 0x39, 0x03, 0x8D, 0x20, 0xA8, 0x15, 0x43, 0x8E, 0xB4, 0xF2, 0xCA, 0xC7, 0xCE, 0x3A, 0x35, 0x0B, + 0x7C, 0x73, 0x54, 0xDB, 0x2E, 0xD9, 0x72, 0x6B, 0x00, 0x00, 0x5C, 0x02, 0xA5, 0x29, 0x83, 0x98, + 0x15, 0x38, 0x41, 0x56, 0xC6, 0x42, 0xB4, 0x60, 0x70, 0x07, 0xC7, 0xEE, 0x6C, 0xA6, 0x25, 0x10, + 0x80, 0xE1, 0x93, 0x04, 0x03, 0x07, 0x41, 0x05, 0xA4, 0x35, 0x55, 0x8C, 0x3C, 0xB3, 0x66, 0x28, + 0xE4, 0x8C, 0x5D, 0xA6, 0x0C, 0xAC, 0x49, 0x3E, 0x0C, 0x69, 0x84, 0x2D, 0xC1, 0x73, 0xB2, 0x14, + 0x99, 0x7D, 0xD6, 0x32, 0x74, 0xB4, 0xE9, 0x5B, 0xA4, 0xBA, 0xD9, 0x3B, 0xC8, 0xA0, 0x09, 0x76, + 0xFB, 0xE9, 0xAF, 0xB4, 0x8A, 0x66, 0x02, 0x9B, 0xF6, 0xDC, 0x07, 0x79, 0x38, 0x40, 0xA0, 0x58, + 0x9C, 0xA9, 0xD6, 0x64, 0xF1, 0xB2, 0x0C, 0x98, 0x0B, 0x89, 0x21, 0x61, 0xA7, 0x51, 0xA5, 0x1B, + 0xFA, 0x96, 0x6F, 0xC7, 0x27, 0x16, 0x3E, 0xEE, 0x9A, 0x92, 0x8E, 0xB4, 0xA5, 0xB8, 0x7F, 0x52, + 0x8B, 0xC0, 0x10, 0x00, 0x00, 0x01, 0x0A, 0xED, 0x80, 0x09, 0x14, 0x52, 0xE8, 0xDC, 0x2B, 0x28, + 0x0C, 0x3D, 0x71, 0x6B, 0x93, 0x54, 0x62, 0x38, 0x62, 0xCC, 0x32, 0xB6, 0x51, 0x41, 0xE1, 0x1B, + 0x44, 0x6F, 0x58, 0x60, 0x55, 0x81, 0xC1, 0x40, 0xB9, 0x87, 0xAD, 0x4C, 0x0F, 0x45, 0x60, 0x66, + 0x0A, 0x61, 0xC5, 0xC2, 0x86, 0xB2, 0x07, 0x83, 0x72, 0x67, 0x24, 0x42, 0x23, 0x14, 0x43, 0x8C, + 0xB2, 0x1A, 0x30, 0x98, 0xB8, 0x2A, 0x3E, 0x38, 0xC0, 0x44, 0xCD, 0xE0, 0xA3, 0x46, 0x95, 0xCC, + 0xA2, 0x11, 0x26, 0x5E, 0x81, 0x03, 0x26, 0x0F, 0x29, 0x1B, 0x8C, 0x82, 0x7D, 0x6E, 0x09, 0x46, + 0x31, 0xA3, 0x13, 0x39, 0x94, 0xA7, 0xE0, 0xC0, 0x00, 0x84, 0x61, 0x11, 0xDC, 0x76, 0x48, 0xCC, + 0xD6, 0x4B, 0x59, 0x77, 0x95, 0x33, 0x6F, 0x22, 0x6A, 0xE4, 0x84, 0x2A, 0xDC, 0x43, 0x34, 0x72, + 0x68, 0xEF, 0xDE, 0x4B, 0x9E, 0x6A, 0x48, 0xCB, 0x5C, 0xFF, 0xFB, 0x92, 0x64, 0x80, 0x8E, 0x03, + 0xC9, 0x2F, 0x49, 0x9B, 0x7A, 0x3A, 0xF0, 0x35, 0x41, 0x09, 0xCD, 0x0C, 0x02, 0x00, 0x0F, 0x2C, + 0xBB, 0x26, 0x4E, 0x68, 0xED, 0x80, 0xDA, 0x85, 0xE7, 0x34, 0x30, 0x88, 0x00, 0x46, 0x35, 0x50, + 0xBF, 0xCB, 0xC1, 0xDE, 0xA8, 0xD6, 0x17, 0x45, 0xC2, 0x82, 0xE5, 0x1E, 0x1F, 0x73, 0xCD, 0x11, + 0xF4, 0x16, 0xCA, 0x7F, 0xAF, 0xF9, 0x07, 0x0B, 0xA2, 0x1D, 0xA2, 0xD9, 0x88, 0xDB, 0x85, 0xCC, + 0x3F, 0x6C, 0x53, 0xA9, 0xD0, 0x80, 0x60, 0x00, 0x00, 0x92, 0xEF, 0xC2, 0x85, 0x75, 0x1D, 0xF0, + 0x4D, 0xA7, 0x0E, 0x93, 0xC5, 0xA4, 0x8B, 0x5C, 0x49, 0x0C, 0x61, 0xCA, 0xC4, 0xE3, 0x87, 0xFE, + 0x8A, 0x9A, 0xC7, 0xD9, 0x01, 0xF6, 0x8A, 0x77, 0xB1, 0xDA, 0x14, 0x6E, 0xA7, 0xA0, 0x44, 0x85, + 0xBE, 0xE7, 0x58, 0x2A, 0x0B, 0xB8, 0x28, 0x68, 0xB5, 0xF3, 0x0A, 0x00, 0x00, 0x54, 0x02, 0x39, + 0x5C, 0x31, 0xC4, 0x16, 0x02, 0x61, 0x44, 0x46, 0x36, 0x16, 0x61, 0x82, 0x47, 0x7F, 0xE4, 0x0D, + 0x34, 0x3B, 0xC6, 0xC3, 0x0A, 0x11, 0x07, 0x33, 0x98, 0x18, 0x4A, 0x40, 0x98, 0xB8, 0xB8, 0x49, + 0x49, 0x8B, 0x02, 0x18, 0x08, 0x98, 0xB1, 0x40, 0x35, 0x1C, 0x52, 0xFA, 0x3C, 0xA1, 0x03, 0x54, + 0x6F, 0x99, 0xC2, 0xD6, 0x87, 0x69, 0x65, 0x71, 0x88, 0xCB, 0x49, 0x47, 0xC6, 0x5B, 0x0A, 0x7F, + 0xD2, 0x41, 0xD8, 0x85, 0x2D, 0x55, 0xD5, 0x4D, 0x61, 0x1B, 0xDA, 0xB4, 0xDC, 0xA5, 0x0E, 0xC0, + 0xE0, 0x17, 0x1E, 0xA4, 0x6B, 0xB6, 0x76, 0x35, 0xB6, 0xE4, 0x9F, 0xFB, 0x3B, 0xE9, 0x1E, 0xA9, + 0x3A, 0xFB, 0xF3, 0x7D, 0xBF, 0x7C, 0x75, 0x3A, 0x40, 0x29, 0xA2, 0xE1, 0x6C, 0xA6, 0x09, 0x33, + 0xDF, 0xF9, 0xEC, 0x5A, 0xF4, 0x54, 0x21, 0x91, 0x44, 0x15, 0x00, 0x00, 0x00, 0x12, 0x52, 0x40, + 0x32, 0x58, 0x17, 0x6B, 0x29, 0xFE, 0xA2, 0x5E, 0xC6, 0x38, 0x3F, 0x61, 0x7E, 0x9A, 0xA5, 0xF7, + 0x6D, 0x93, 0xDF, 0xA3, 0xE8, 0xD5, 0x12, 0x06, 0x5A, 0x24, 0x17, 0x99, 0xA4, 0xAA, 0x88, 0xD8, + 0x75, 0x40, 0x05, 0x12, 0x08, 0x14, 0x70, 0x77, 0x33, 0x5B, 0x8B, 0xA2, 0xE6, 0x4C, 0x40, 0x7E, + 0x4E, 0x92, 0x81, 0x01, 0x48, 0x8F, 0x1D, 0xC0, 0x22, 0x40, 0xC5, 0xC1, 0x8C, 0x50, 0x6C, 0xC3, + 0x7C, 0xC2, 0x07, 0x0E, 0x9E, 0xCC, 0x59, 0xB8, 0xD4, 0x90, 0x4C, 0xE4, 0x8C, 0x51, 0xCF, 0x39, + 0x85, 0xE4, 0x4F, 0xB3, 0xCD, 0x12, 0x10, 0x0D, 0x84, 0xDC, 0x24, 0x13, 0x06, 0x1C, 0x50, 0xFB, + 0x3A, 0x87, 0x5D, 0xE1, 0xA4, 0xD4, 0x87, 0x10, 0xEE, 0xA4, 0x1C, 0x44, 0xBD, 0xB1, 0x7D, 0xE2, + 0x5F, 0x8A, 0xA9, 0x4A, 0xD9, 0x60, 0xE8, 0x3F, 0xEE, 0x59, 0x59, 0xB0, 0x6C, 0xC8, 0x00, 0x05, + 0xDE, 0xAE, 0x25, 0x4C, 0xC6, 0xD8, 0xEC, 0x7D, 0xD4, 0xCD, 0x39, 0xF7, 0x77, 0xBF, 0xDA, 0xF2, + 0xDE, 0x9F, 0x3B, 0xAF, 0x39, 0x9D, 0xE0, 0xEA, 0x50, 0x9C, 0x92, 0xFF, 0xFB, 0x90, 0x64, 0x90, + 0x06, 0x43, 0xE8, 0x31, 0x4A, 0x1B, 0x79, 0x4B, 0xD0, 0x36, 0x21, 0x39, 0xED, 0x04, 0x23, 0x04, + 0x8F, 0x08, 0xC3, 0x28, 0xCD, 0xE4, 0xCB, 0xC0, 0xD1, 0x83, 0xA7, 0x28, 0x30, 0x0C, 0xC8, 0xA1, + 0x14, 0xEB, 0xE7, 0x3F, 0xDC, 0xBF, 0xF9, 0x05, 0xF4, 0xC4, 0xB8, 0x00, 0x00, 0x91, 0xEF, 0xC2, + 0x0A, 0xBC, 0x6A, 0x74, 0x46, 0x07, 0x07, 0xC0, 0xD1, 0x67, 0x24, 0x64, 0x58, 0xE2, 0x5B, 0xB1, + 0x52, 0x1A, 0xDD, 0x94, 0x4B, 0xB7, 0xFA, 0xED, 0xBC, 0x0A, 0x9A, 0x2E, 0x59, 0xF3, 0x8D, 0x4A, + 0xAB, 0x68, 0x86, 0x69, 0x85, 0xD8, 0x15, 0x0A, 0x03, 0x11, 0x05, 0x77, 0xB5, 0xCC, 0xBA, 0x00, + 0x0D, 0x09, 0x96, 0xBC, 0x61, 0xE2, 0x87, 0x24, 0x9A, 0x65, 0x43, 0x21, 0x62, 0x83, 0x52, 0x7A, + 0x35, 0xC2, 0x83, 0x0F, 0x08, 0x37, 0x09, 0xE3, 0x4E, 0x0D, 0x33, 0x78, 0x80, 0x75, 0xE3, 0x04, + 0xCC, 0xD0, 0x0F, 0x22, 0xD0, 0x17, 0x7A, 0x62, 0x86, 0x9A, 0x44, 0x42, 0xE7, 0xC7, 0x04, 0xCA, + 0xDA, 0x50, 0xF5, 0xF7, 0xEA, 0x8C, 0x64, 0x0A, 0x0B, 0x3B, 0x74, 0xCA, 0xB5, 0x35, 0x57, 0x02, + 0x2F, 0xB5, 0x06, 0xD2, 0x9D, 0x54, 0x8B, 0xBF, 0x03, 0xC4, 0x9B, 0x8A, 0x4C, 0x5C, 0xB7, 0x3B, + 0x14, 0x7F, 0x62, 0x45, 0xCE, 0x31, 0x64, 0x6A, 0x36, 0x06, 0x7C, 0xDA, 0x4B, 0x02, 0x27, 0x4A, + 0x8B, 0x98, 0x59, 0xC5, 0x7D, 0x1B, 0x73, 0x17, 0x3B, 0x5C, 0x73, 0x71, 0x97, 0x58, 0x72, 0x1D, + 0x9A, 0x70, 0x61, 0xF8, 0x38, 0xF2, 0xB2, 0xAE, 0x2C, 0xA7, 0xBB, 0xFF, 0x4C, 0x80, 0x01, 0x20, + 0xC9, 0x31, 0x0E, 0x4F, 0x7A, 0xF5, 0x24, 0xAC, 0x1D, 0xE1, 0xB8, 0xAC, 0xD0, 0x53, 0x31, 0x35, + 0x10, 0x0B, 0x46, 0x24, 0x85, 0x2C, 0xB7, 0xAB, 0xFE, 0x54, 0x36, 0x02, 0x80, 0x8B, 0x08, 0x1E, + 0x4C, 0x1C, 0x1F, 0xDB, 0xB1, 0x8B, 0x7D, 0x0B, 0xB5, 0xA5, 0x9D, 0x11, 0x3C, 0x87, 0x14, 0x0C, + 0x22, 0x0D, 0xD4, 0x42, 0x0E, 0x19, 0x66, 0x46, 0x93, 0x07, 0x20, 0x10, 0x98, 0xC6, 0xB2, 0xA8, + 0xCA, 0x4A, 0xF0, 0x38, 0x5C, 0x30, 0x60, 0x71, 0x30, 0x88, 0x11, 0x18, 0x36, 0x4C, 0x41, 0x14, + 0x44, 0x62, 0xD1, 0x93, 0xA3, 0xA9, 0x95, 0xE3, 0x29, 0x82, 0xA1, 0xB8, 0x90, 0x78, 0xCA, 0x4D, + 0x94, 0x01, 0x75, 0x86, 0x04, 0x18, 0xEF, 0x04, 0xC9, 0x48, 0x51, 0x53, 0xB9, 0x31, 0xC6, 0x66, + 0x61, 0x40, 0x80, 0xE8, 0xAC, 0xF5, 0x8B, 0x0D, 0x82, 0x3D, 0xCA, 0x1C, 0x44, 0xB6, 0x45, 0x2B, + 0x57, 0x8F, 0xFE, 0x32, 0xF9, 0x22, 0x82, 0x26, 0x22, 0xF8, 0x58, 0x84, 0x66, 0x54, 0xCF, 0x13, + 0x42, 0x6D, 0x59, 0xC2, 0xCB, 0x17, 0x49, 0x43, 0xA7, 0x46, 0xEF, 0x49, 0xD2, 0x45, 0xBF, 0x47, + 0xAE, 0xB1, 0xD8, 0x3E, 0x8E, 0x30, 0x80, 0x74, 0x45, 0xE9, 0xFE, 0x34, 0x05, 0x16, 0x1B, 0x24, + 0xE7, 0x88, 0xDE, 0x8D, 0x40, 0x00, 0x08, 0x22, 0x09, 0x20, 0x16, 0x82, 0xFF, 0xFB, 0x92, 0x64, + 0x9E, 0x8E, 0x03, 0xED, 0x30, 0x49, 0x93, 0x7A, 0x42, 0xF0, 0x32, 0x61, 0x7A, 0x19, 0x08, 0x02, + 0x33, 0x90, 0x90, 0xB5, 0x22, 0x4E, 0xE1, 0xAF, 0x40, 0xBE, 0x1B, 0x27, 0xE8, 0x70, 0x0F, 0xC2, + 0xD3, 0x77, 0x47, 0xAB, 0xCF, 0x4F, 0xAF, 0x4B, 0x52, 0xB5, 0x4A, 0xFD, 0xBF, 0x37, 0xA7, 0xFF, + 0xF4, 0x53, 0x68, 0x94, 0x98, 0xEA, 0x47, 0x24, 0xBC, 0xA5, 0x82, 0x60, 0xE8, 0xE0, 0x15, 0xD7, + 0xA2, 0xA5, 0x4B, 0xBE, 0xC6, 0x7F, 0xEA, 0xC0, 0x00, 0x04, 0x02, 0xAB, 0xB6, 0xD8, 0x66, 0x7E, + 0x1C, 0x34, 0x19, 0x33, 0x69, 0x97, 0xF2, 0x08, 0xC8, 0xAA, 0x25, 0x45, 0x24, 0x48, 0x09, 0x2B, + 0xA0, 0xAF, 0x0B, 0xD1, 0x04, 0x2A, 0x47, 0x5D, 0xA8, 0xE1, 0x48, 0x6C, 0x5C, 0xD3, 0x51, 0x79, + 0x3D, 0x75, 0x49, 0x9D, 0xB1, 0x4A, 0xA4, 0x48, 0xF1, 0xB5, 0x6F, 0xD4, 0x29, 0xEE, 0xA2, 0xE7, + 0x8D, 0x5C, 0x6B, 0x0F, 0x52, 0x65, 0xF3, 0x1C, 0xDA, 0x3F, 0xF9, 0xC6, 0x00, 0xA5, 0xE5, 0x33, + 0x01, 0x8B, 0xFA, 0x7D, 0x9E, 0x45, 0xBE, 0xE4, 0xEF, 0x6E, 0x2F, 0xFF, 0xF4, 0xA8, 0x00, 0x00, + 0x02, 0x00, 0x62, 0x39, 0x20, 0xA8, 0x4E, 0xF5, 0xEA, 0x65, 0x9F, 0xA3, 0x5A, 0x61, 0xF5, 0xAF, + 0xEB, 0xF7, 0xF6, 0xCD, 0x14, 0x15, 0x54, 0x98, 0xBE, 0xAE, 0xD4, 0x67, 0x0E, 0x8D, 0xCD, 0xEC, + 0x1A, 0x35, 0x08, 0x42, 0x9D, 0x2A, 0xB7, 0x92, 0x5A, 0xA6, 0x94, 0xAC, 0xDE, 0xE5, 0x37, 0xFE, + 0xE0, 0x04, 0x20, 0x9B, 0x7E, 0x04, 0x43, 0xA3, 0x32, 0xFC, 0x4C, 0x7C, 0x25, 0x05, 0x0C, 0x0C, + 0x18, 0x61, 0x3B, 0x12, 0xBC, 0x2E, 0x0A, 0x32, 0x91, 0x90, 0x59, 0x6E, 0x68, 0x78, 0x29, 0x8E, + 0x06, 0x66, 0x51, 0x58, 0x1A, 0x78, 0xC2, 0x30, 0xE9, 0x1A, 0x37, 0x98, 0xB0, 0x6C, 0x7F, 0x92, + 0x36, 0x83, 0x1C, 0x2E, 0x48, 0x4B, 0x48, 0xA2, 0x80, 0xD1, 0x20, 0x80, 0x2F, 0x93, 0x24, 0x93, + 0x0F, 0x62, 0x8B, 0x35, 0x85, 0x4C, 0x4A, 0x42, 0x0D, 0x2D, 0xA8, 0x71, 0x4C, 0x0B, 0xE8, 0xD6, + 0x92, 0x28, 0xB9, 0xAB, 0x41, 0x81, 0x50, 0xC1, 0x2C, 0x8E, 0x56, 0xC4, 0x99, 0x62, 0x5E, 0xBD, + 0x2D, 0xAC, 0xFB, 0xAC, 0xA1, 0x45, 0xCD, 0x30, 0x3A, 0x46, 0x43, 0xE6, 0x5D, 0x34, 0x46, 0xA1, + 0x9A, 0x76, 0x61, 0xF3, 0x20, 0x22, 0x69, 0xB9, 0x8F, 0xEF, 0xF2, 0x68, 0x74, 0xB2, 0x51, 0x88, + 0x80, 0x00, 0x01, 0xED, 0xF8, 0x08, 0xAD, 0xF1, 0xCF, 0xA2, 0xBE, 0xFF, 0x15, 0x76, 0x26, 0x80, + 0x9F, 0x3C, 0xCB, 0x3D, 0x7E, 0x77, 0x6B, 0x37, 0xEA, 0x5F, 0x6D, 0x1E, 0x5B, 0x53, 0x03, 0x53, + 0x90, 0x2A, 0x03, 0x99, 0x20, 0x54, 0x0E, 0x4F, 0x16, 0x69, 0xB7, 0x8B, 0x0D, 0xA8, 0x6C, 0xB2, + 0xE9, 0x5C, 0x16, 0x00, 0x89, 0x08, 0x89, 0x28, 0x30, 0x8C, 0xAC, 0xE7, 0xD3, 0xC2, 0x3F, 0xCC, + 0x98, 0x6C, 0xCC, 0x4D, 0x4C, 0x69, 0xB8, 0xD3, 0x8F, 0x0D, 0x11, 0xD4, 0xCD, 0xCD, 0xFF, 0xFB, + 0x92, 0x64, 0xAB, 0x80, 0x02, 0xB1, 0x2D, 0xD0, 0x53, 0x0B, 0x2C, 0x34, 0x33, 0x65, 0x0A, 0x0D, + 0x1C, 0x02, 0xD0, 0x8F, 0xCC, 0xB7, 0x20, 0x4E, 0x65, 0x4F, 0x40, 0xD0, 0x95, 0x27, 0x28, 0x30, + 0x8A, 0x30, 0xCD, 0xA2, 0x30, 0xB0, 0x7C, 0x66, 0x21, 0x62, 0xE4, 0xA7, 0x49, 0xC0, 0x60, 0x26, + 0xA6, 0x54, 0x02, 0x71, 0x1C, 0x67, 0x9E, 0xAF, 0x55, 0x38, 0xD0, 0x23, 0xEC, 0x85, 0xC3, 0x49, + 0x11, 0xD6, 0x5B, 0xE6, 0xDA, 0x22, 0xD1, 0x1A, 0x3C, 0x82, 0x69, 0x1D, 0xF9, 0x3C, 0xC1, 0x95, + 0xA1, 0x8E, 0x2E, 0xEB, 0xAC, 0x11, 0xE9, 0x86, 0x9B, 0xBC, 0xCB, 0x42, 0x54, 0x89, 0x1C, 0x5A, + 0xE6, 0xE5, 0x4B, 0x24, 0x77, 0xC6, 0xC7, 0xF3, 0xA9, 0x8B, 0x8F, 0x5B, 0x09, 0x6F, 0xF4, 0x55, + 0x88, 0x7A, 0x89, 0x77, 0xF9, 0x6E, 0xFF, 0x73, 0x85, 0xEE, 0x24, 0xE6, 0xE7, 0xBC, 0x93, 0xFD, + 0x41, 0x66, 0xC3, 0x60, 0xE5, 0xD6, 0xFF, 0xD3, 0x55, 0xF8, 0x00, 0x00, 0x00, 0x06, 0xBB, 0x70, + 0xCF, 0x20, 0x1C, 0x0A, 0x2E, 0x17, 0xA7, 0x4A, 0xDC, 0xB4, 0x77, 0xD8, 0xF5, 0x69, 0xB3, 0xF1, + 0x71, 0x71, 0x6E, 0xC6, 0xD1, 0x4D, 0x85, 0x8D, 0x4C, 0xA9, 0xBC, 0xF3, 0x5F, 0xD4, 0x0A, 0x8C, + 0x7C, 0x59, 0x4B, 0x52, 0xEB, 0x7A, 0x93, 0x30, 0x03, 0x11, 0x1B, 0x38, 0x41, 0x95, 0xBF, 0x46, + 0x33, 0x10, 0x1E, 0x99, 0x92, 0x6A, 0x70, 0x81, 0x8D, 0xC8, 0x26, 0x15, 0x3A, 0x18, 0xF9, 0xBC, + 0x6D, 0xA0, 0x01, 0x85, 0x08, 0x06, 0x4C, 0x12, 0x1B, 0x7C, 0xE2, 0x1C, 0x67, 0x19, 0x09, 0x98, + 0x38, 0xC8, 0x73, 0xFA, 0x99, 0x82, 0xCA, 0xC1, 0x82, 0xD3, 0x53, 0xA4, 0x90, 0x00, 0x8E, 0x08, + 0x48, 0x11, 0x91, 0x45, 0x08, 0x88, 0x8D, 0x60, 0xD5, 0xDF, 0xCC, 0x12, 0x71, 0x5D, 0xE1, 0x2A, + 0xAE, 0x8D, 0x8D, 0x6E, 0x52, 0xF2, 0x1C, 0x01, 0x41, 0xE9, 0xA3, 0x6D, 0x0D, 0x64, 0x0F, 0x93, + 0x47, 0x56, 0x34, 0xC0, 0x77, 0xC1, 0x29, 0x95, 0x1F, 0x67, 0xF0, 0x09, 0x40, 0x49, 0xD0, 0xF4, + 0xB3, 0x4C, 0x7E, 0xD6, 0x34, 0x97, 0x26, 0x64, 0xF1, 0xCE, 0xF3, 0x23, 0x72, 0xF7, 0x59, 0x8A, + 0xF1, 0xC1, 0xB1, 0xFF, 0x97, 0xF9, 0xF2, 0x13, 0x48, 0x1C, 0x87, 0x79, 0xD9, 0x53, 0xA3, 0x66, + 0x87, 0xEB, 0x9D, 0xF7, 0xEB, 0xF7, 0x69, 0x80, 0x90, 0x88, 0xB2, 0x01, 0xE5, 0xE6, 0x12, 0x20, + 0x24, 0x9E, 0xE6, 0xFF, 0xE5, 0x03, 0xF5, 0xC8, 0x67, 0xF4, 0x76, 0xFF, 0xFA, 0x1C, 0xAB, 0xEB, + 0xA0, 0xB9, 0xEB, 0x3F, 0xF4, 0xD9, 0x79, 0x7E, 0x48, 0x59, 0x93, 0x0F, 0x0C, 0x1F, 0x17, 0x38, + 0x6A, 0x98, 0x9E, 0xBA, 0xF3, 0x14, 0x15, 0x55, 0x00, 0x01, 0x86, 0x94, 0x5F, 0x52, 0xD4, 0x1B, + 0x26, 0xA8, 0x19, 0x0B, 0x01, 0x0D, 0x0C, 0x84, 0x07, 0x33, 0xDC, 0x3C, 0x42, 0x0D, 0x30, 0xE0, + 0x10, 0xC3, 0x01, 0x60, 0xEA, 0x49, 0x86, 0x0F, 0xA6, 0x36, 0x0D, 0x33, 0x23, 0x04, 0x3B, 0x8C, + 0xFF, 0xFB, 0x92, 0x64, 0xCC, 0x8C, 0x04, 0x13, 0x34, 0x48, 0x93, 0x79, 0x4B, 0xD0, 0x33, 0x60, + 0x99, 0xCA, 0x24, 0x02, 0x10, 0x11, 0x48, 0xD1, 0x1E, 0x0E, 0x65, 0x6F, 0x80, 0xC2, 0x87, 0xE9, + 0xB0, 0x30, 0x98, 0x6E, 0x2A, 0x19, 0x0E, 0x26, 0xA4, 0xC9, 0x19, 0x4A, 0x38, 0xA0, 0x24, 0x32, + 0x45, 0xF5, 0xD6, 0xB1, 0x06, 0x5A, 0x9E, 0x36, 0x18, 0x0A, 0x40, 0x89, 0x19, 0xFD, 0x6D, 0x96, + 0x12, 0x05, 0x77, 0x04, 0x4C, 0x00, 0x12, 0x32, 0xAD, 0xCE, 0x42, 0xE6, 0x87, 0x1B, 0xF8, 0xC3, + 0xEC, 0xD3, 0x55, 0x91, 0x4B, 0xD8, 0xAC, 0x35, 0x0C, 0xB0, 0xF5, 0xAA, 0x94, 0x21, 0x34, 0xFA, + 0xF2, 0xD7, 0x28, 0x8D, 0xF9, 0xF8, 0xFA, 0xAE, 0x56, 0x19, 0xB4, 0x3D, 0x32, 0xBA, 0x39, 0x9C, + 0x70, 0xF5, 0xA8, 0xCA, 0x94, 0x8F, 0x6D, 0xBB, 0xD3, 0x94, 0x34, 0xD7, 0x19, 0xA5, 0x5D, 0x6F, + 0x77, 0xFE, 0xEA, 0x15, 0x8A, 0xE1, 0x2A, 0x90, 0x00, 0x01, 0xD0, 0x64, 0x25, 0x1D, 0xFC, 0x4B, + 0x43, 0x38, 0x44, 0x18, 0x95, 0x39, 0x05, 0x0F, 0x44, 0x2B, 0xAD, 0x37, 0xB3, 0x51, 0x73, 0xFD, + 0xB4, 0xFB, 0xFA, 0x85, 0x2E, 0xFB, 0x7F, 0x6A, 0x91, 0x42, 0x74, 0x2C, 0xD2, 0xE4, 0xD1, 0x12, + 0x16, 0xAD, 0x06, 0x46, 0xA7, 0x69, 0x49, 0xA4, 0x8A, 0x9D, 0x99, 0x05, 0x39, 0x45, 0xB3, 0x01, + 0x07, 0x33, 0x1E, 0xA3, 0x18, 0x0C, 0x22, 0x11, 0x30, 0x45, 0xF3, 0x10, 0xD9, 0x34, 0x59, 0x33, + 0x3E, 0x33, 0x18, 0x04, 0x0E, 0x32, 0x05, 0x34, 0x99, 0xA8, 0x58, 0x14, 0x04, 0xCA, 0xB9, 0xC0, + 0x4D, 0x26, 0x6C, 0x2A, 0x1D, 0x3E, 0x50, 0xF0, 0xD0, 0x48, 0x41, 0x9F, 0x13, 0x99, 0x64, 0x86, + 0xA9, 0xB5, 0x59, 0x12, 0x89, 0x26, 0x42, 0xFE, 0x8A, 0xC0, 0xA9, 0x7E, 0xBD, 0x1E, 0xE7, 0x3E, + 0x12, 0xF7, 0xE4, 0xCB, 0xD3, 0x4E, 0x39, 0x39, 0x1D, 0x0B, 0x89, 0x26, 0x69, 0x2B, 0xA0, 0x7B, + 0x57, 0x6E, 0x6D, 0xDA, 0x7B, 0x3F, 0x06, 0x83, 0xCC, 0x58, 0x77, 0x16, 0x5F, 0x7A, 0x74, 0x5A, + 0x8A, 0xFF, 0xFF, 0xCD, 0xDF, 0xAC, 0xF7, 0x88, 0x5A, 0x40, 0x6A, 0xFF, 0xA3, 0xF8, 0x80, 0xB0, + 0xF7, 0xFD, 0x1F, 0xFD, 0x34, 0x75, 0xFF, 0xFF, 0xFA, 0xD8, 0x02, 0x01, 0x61, 0x73, 0x7E, 0x0E, + 0x06, 0x0C, 0x68, 0x56, 0x20, 0xB0, 0x50, 0xAB, 0xB1, 0x7C, 0xDB, 0xF7, 0x0B, 0x72, 0xFF, 0xB7, + 0x80, 0x1D, 0x3E, 0xA2, 0x5A, 0x51, 0x57, 0x15, 0x3A, 0xED, 0xA7, 0x89, 0xB8, 0xE8, 0x58, 0x79, + 0x33, 0x8C, 0xB5, 0xB7, 0xA2, 0xC7, 0x29, 0x2C, 0xC5, 0x55, 0xE2, 0x8A, 0xA8, 0x91, 0xE6, 0x2C, + 0x26, 0x1B, 0x18, 0xBE, 0x4D, 0x34, 0x32, 0x38, 0x7C, 0x50, 0xA0, 0x65, 0xC5, 0xD1, 0xCA, 0xC8, + 0xA6, 0x2E, 0x20, 0x01, 0x00, 0xA6, 0x30, 0x10, 0x8F, 0x1F, 0x4C, 0x92, 0x3D, 0x36, 0x79, 0x54, + 0xD9, 0xAA, 0xE0, 0xC0, 0x48, 0x29, 0x50, 0x61, 0xC3, 0x91, 0x81, 0xC6, 0xA5, 0xB5, 0x52, 0xC1, + 0x20, 0xC8, 0xFF, 0xFB, 0x92, 0x64, 0xD3, 0x0E, 0x24, 0x5A, 0x33, 0xC8, 0x93, 0x98, 0x63, 0xD0, + 0x33, 0xC0, 0xE9, 0xCD, 0x05, 0x26, 0x00, 0x0F, 0xC8, 0xCB, 0x26, 0x6D, 0xE4, 0xD1, 0x00, 0xC8, + 0x83, 0x67, 0x34, 0x31, 0x0C, 0x48, 0xF3, 0x15, 0x12, 0x48, 0x82, 0xC5, 0x86, 0x8F, 0xB1, 0xF0, + 0x60, 0xC8, 0x3C, 0xBD, 0x20, 0xA5, 0xF2, 0x08, 0x0B, 0xA3, 0x06, 0x10, 0x4C, 0x58, 0xEB, 0x69, + 0x04, 0x8A, 0x52, 0x63, 0x35, 0xC5, 0x74, 0xF5, 0xA2, 0x4D, 0x84, 0xA3, 0x0E, 0x18, 0xD6, 0x24, + 0x12, 0xF8, 0xEB, 0xEF, 0x22, 0x18, 0x1F, 0x3A, 0x89, 0x50, 0xA6, 0xC6, 0x41, 0x44, 0xCE, 0x79, + 0x75, 0x77, 0xFF, 0xF1, 0x6B, 0xFC, 0x5A, 0xC5, 0xE7, 0xC6, 0xD6, 0x8F, 0x23, 0x0F, 0x71, 0xB7, + 0x05, 0xC4, 0x22, 0x65, 0xEE, 0xFD, 0x09, 0x6D, 0x8A, 0x00, 0x85, 0x00, 0x42, 0xC0, 0x54, 0x15, + 0x3B, 0x52, 0xDF, 0xD6, 0x99, 0xF3, 0x27, 0xEE, 0x4B, 0xB5, 0xFF, 0xE5, 0xC3, 0x62, 0x21, 0x64, + 0xA5, 0x6C, 0xFF, 0xB4, 0x83, 0x9E, 0xB9, 0x51, 0x84, 0xD6, 0x0F, 0x3C, 0x97, 0x16, 0xF9, 0xA0, + 0xC9, 0x66, 0x89, 0x0F, 0x0D, 0x0D, 0x12, 0x61, 0x21, 0xA2, 0xE0, 0x00, 0x41, 0x4E, 0xD7, 0x74, + 0x08, 0x81, 0xCE, 0x64, 0xA0, 0xE8, 0x87, 0x48, 0x8E, 0x00, 0x34, 0x46, 0x15, 0x58, 0x65, 0xE1, + 0x47, 0x00, 0x7C, 0x1C, 0xA0, 0x64, 0x4F, 0x06, 0x8A, 0xB4, 0x58, 0x7D, 0x3B, 0x34, 0x23, 0x98, + 0x77, 0x33, 0xE0, 0x23, 0x10, 0x03, 0x05, 0x09, 0x9C, 0x48, 0x41, 0x00, 0x0A, 0x0D, 0x98, 0x94, + 0xB7, 0x62, 0xAA, 0xE4, 0x64, 0xE9, 0xCA, 0xF9, 0x4C, 0x43, 0xED, 0x69, 0x85, 0x97, 0xDA, 0x1C, + 0x87, 0x19, 0xEA, 0xE9, 0x16, 0x53, 0x11, 0x68, 0x4E, 0xA2, 0x48, 0xC3, 0xAE, 0x4E, 0xA6, 0x63, + 0x6D, 0x6D, 0x43, 0x40, 0xC3, 0xAD, 0x9D, 0x0E, 0x47, 0x0B, 0x03, 0x56, 0x11, 0x4F, 0xA1, 0x83, + 0x15, 0x37, 0x49, 0xBD, 0xF9, 0x5E, 0xC8, 0x5C, 0xA8, 0x96, 0x22, 0x8F, 0xBF, 0xD0, 0x44, 0x51, + 0x59, 0x7F, 0xEE, 0x73, 0x11, 0x7B, 0xBB, 0xBF, 0xC5, 0xD5, 0xD8, 0x32, 0x77, 0xF4, 0x7F, 0x25, + 0x4C, 0x40, 0x00, 0x00, 0x0F, 0xB0, 0xFC, 0x4D, 0xCC, 0x7F, 0x0B, 0xD3, 0xFA, 0x7E, 0xFF, 0xF6, + 0xFE, 0x80, 0x71, 0x42, 0xB6, 0xE8, 0x47, 0xD7, 0x6B, 0xDD, 0x0E, 0xAA, 0x54, 0xB5, 0xDC, 0x97, + 0x1E, 0xC7, 0x0A, 0x3B, 0xFF, 0x4B, 0x84, 0x61, 0xC1, 0x42, 0x7A, 0xAE, 0x6B, 0x18, 0x39, 0x2A, + 0x03, 0xF6, 0xC8, 0xD5, 0xC0, 0x00, 0x00, 0x00, 0x51, 0x97, 0x79, 0x95, 0x66, 0x0B, 0x0C, 0x98, + 0x25, 0xA9, 0x8F, 0x05, 0x83, 0x87, 0x02, 0xA2, 0x60, 0x56, 0x90, 0x31, 0xC1, 0x91, 0x8B, 0x89, + 0x11, 0x99, 0x2A, 0x0A, 0x02, 0xC1, 0xC9, 0x03, 0x48, 0x06, 0xC6, 0x62, 0x28, 0x14, 0x15, 0x03, + 0x0E, 0x0B, 0x53, 0x07, 0x2A, 0x56, 0x18, 0x82, 0x26, 0x76, 0x21, 0xC3, 0x2C, 0x5A, 0xE9, 0x23, + 0x12, 0xE6, 0xD1, 0xC9, 0xFF, 0xFB, 0x92, 0x64, 0xDA, 0x0C, 0x04, 0x38, 0x33, 0xC8, 0x03, 0x98, + 0x5C, 0xB0, 0x33, 0x60, 0x0A, 0x0C, 0x04, 0x22, 0x5F, 0x90, 0xC8, 0xD1, 0x24, 0x6D, 0xE0, 0xF1, + 0x00, 0xCA, 0x17, 0x27, 0x68, 0x10, 0x15, 0x88, 0xD2, 0x72, 0x10, 0xC0, 0x54, 0x45, 0x65, 0x57, + 0xAD, 0xCC, 0xD5, 0x45, 0xAC, 0xC4, 0x1C, 0x80, 0xFE, 0x79, 0x9D, 0xE4, 0x60, 0x40, 0x7D, 0x18, + 0xE3, 0xD1, 0x9B, 0xFF, 0x13, 0x7E, 0x9A, 0x32, 0x3E, 0x71, 0x71, 0xDC, 0x97, 0x11, 0x06, 0x1A, + 0x3B, 0x67, 0x66, 0xBF, 0xB9, 0xDF, 0x88, 0xF4, 0x8C, 0x50, 0xB0, 0xDB, 0x45, 0x98, 0xFB, 0xFF, + 0xF7, 0xC0, 0x00, 0x00, 0x01, 0x34, 0x5B, 0xC4, 0xC2, 0x50, 0x34, 0x07, 0x81, 0x33, 0xE1, 0x8C, + 0x11, 0x0B, 0x19, 0x2A, 0x5D, 0xED, 0x92, 0xB7, 0xC8, 0x21, 0x4C, 0x45, 0x76, 0xAD, 0x68, 0x64, + 0x7F, 0xFE, 0xA1, 0x0E, 0x36, 0x65, 0xD7, 0xE7, 0xB3, 0xDB, 0xE8, 0xDA, 0x44, 0x3D, 0x71, 0x77, + 0x19, 0x14, 0x63, 0xEB, 0x00, 0x58, 0x73, 0xBE, 0x62, 0xF2, 0xA9, 0x9F, 0x07, 0xA6, 0xCF, 0x1C, + 0x18, 0xB0, 0x76, 0x67, 0x34, 0x71, 0xE6, 0x96, 0x66, 0x3F, 0x3B, 0x22, 0xA9, 0xBD, 0xCD, 0x47, + 0x26, 0x65, 0x19, 0xBC, 0x8E, 0x69, 0x52, 0x00, 0x09, 0x5C, 0x7D, 0x6A, 0x31, 0x8A, 0x83, 0x06, + 0x1F, 0x29, 0x07, 0x06, 0xC8, 0xA3, 0x23, 0xA1, 0x82, 0xE3, 0x03, 0x04, 0x84, 0x03, 0x44, 0xA7, + 0x67, 0xE1, 0x46, 0x9D, 0x55, 0x03, 0x29, 0x80, 0xF3, 0x9F, 0xC0, 0xB0, 0x19, 0xA9, 0x12, 0x0B, + 0xF6, 0xB2, 0x49, 0x94, 0x00, 0x43, 0x7C, 0xAA, 0x08, 0x0C, 0x40, 0x1B, 0xBB, 0x3B, 0x19, 0x7F, + 0x34, 0xA6, 0xE5, 0x9F, 0x16, 0x7A, 0xD5, 0xB8, 0x9D, 0x10, 0x24, 0x00, 0xDB, 0x48, 0xFE, 0x55, + 0x61, 0x7F, 0x48, 0xE8, 0x20, 0x9B, 0x3F, 0xFF, 0xF0, 0xFF, 0xE1, 0x83, 0xF7, 0x72, 0xFF, 0xAE, + 0x78, 0xB1, 0xF4, 0xE2, 0xA8, 0x5D, 0x1D, 0x64, 0x88, 0xE4, 0x9E, 0xC5, 0x56, 0x6D, 0x66, 0xFF, + 0xFD, 0x3F, 0x4F, 0xEE, 0xFA, 0x5F, 0xF7, 0xFF, 0xD4, 0x20, 0x0A, 0x8E, 0x4A, 0x38, 0x29, 0x8F, + 0x81, 0xEC, 0xF1, 0xAE, 0xC7, 0xD6, 0x24, 0xE3, 0x80, 0x83, 0x4F, 0x44, 0xFA, 0x68, 0xB7, 0x2C, + 0x89, 0xD7, 0xFE, 0x49, 0xAF, 0x13, 0x9E, 0x09, 0x5C, 0x3A, 0x2A, 0xFD, 0x27, 0x47, 0x84, 0x54, + 0x41, 0xA9, 0x22, 0xB7, 0x02, 0x0C, 0xD1, 0xDE, 0x6A, 0xBC, 0x9A, 0x98, 0x11, 0x36, 0xF0, 0xEB, + 0xC2, 0xEB, 0x73, 0xD5, 0x80, 0x00, 0x00, 0x12, 0x4E, 0x3C, 0x4A, 0x2A, 0x61, 0x47, 0xA6, 0x90, + 0x12, 0x12, 0x1C, 0x22, 0x13, 0x36, 0x08, 0x20, 0x0F, 0x00, 0x24, 0x88, 0xCB, 0x06, 0x4D, 0x70, + 0x18, 0xE5, 0xD4, 0x80, 0xC3, 0x26, 0x06, 0x40, 0x6E, 0xEB, 0xC6, 0x7B, 0xDE, 0x01, 0x4C, 0x40, + 0x10, 0x80, 0x41, 0x95, 0x16, 0xA6, 0x44, 0xC0, 0x10, 0xD0, 0x24, 0x8B, 0x73, 0x41, 0x1C, 0xC3, + 0x2D, 0x65, 0xED, 0x28, 0x40, 0x0E, 0xFF, 0xFB, 0x92, 0x64, 0xDF, 0x04, 0x83, 0xC9, 0x33, 0xCB, + 0xD3, 0x6F, 0x2C, 0x40, 0x32, 0xE0, 0x69, 0xBA, 0x04, 0x63, 0x00, 0x12, 0x9C, 0xCF, 0x1C, 0x2E, + 0x61, 0x33, 0x10, 0xE9, 0x85, 0xE7, 0xDC, 0x03, 0x08, 0x1A, 0x2A, 0xC1, 0x91, 0x39, 0x40, 0x9B, + 0xC6, 0xE2, 0x9F, 0x23, 0x4A, 0x21, 0x4C, 0x62, 0x1B, 0x62, 0x12, 0xB7, 0x7E, 0x8D, 0x88, 0xBF, + 0xEA, 0xF4, 0xBA, 0x0D, 0x09, 0xAE, 0x5E, 0x9E, 0x5F, 0x82, 0xD8, 0xA6, 0xB2, 0x41, 0x8B, 0x8B, + 0x85, 0xE6, 0x7F, 0xD0, 0xE2, 0x6F, 0xC6, 0x24, 0xA5, 0x06, 0xD9, 0x10, 0xF8, 0x23, 0x77, 0x8A, + 0xD8, 0xCB, 0x3B, 0xFE, 0x85, 0x7F, 0xCD, 0xAE, 0xB2, 0x77, 0xA4, 0xFD, 0xDD, 0xEC, 0xAF, 0xD5, + 0x80, 0x00, 0x18, 0x17, 0x34, 0x41, 0x31, 0xC6, 0xC2, 0x77, 0xAE, 0x4B, 0xF2, 0x08, 0x48, 0xAD, + 0xDF, 0xF7, 0xE1, 0x03, 0x22, 0x14, 0x2B, 0x3D, 0xBC, 0xBD, 0xEE, 0x5F, 0xDB, 0xA4, 0x02, 0xED, + 0x26, 0xA2, 0xE1, 0xE4, 0x39, 0x36, 0xA0, 0x76, 0xB7, 0x7A, 0x8B, 0x6F, 0x4D, 0x3B, 0x01, 0x42, + 0x61, 0x8D, 0x66, 0x46, 0x21, 0x0D, 0x0C, 0x07, 0x0C, 0x4E, 0x2C, 0x32, 0x54, 0x1C, 0xC4, 0x42, + 0x73, 0x3D, 0x85, 0xCC, 0x60, 0x32, 0x36, 0x31, 0x74, 0xC9, 0x07, 0x63, 0x1C, 0xA6, 0x0C, 0x06, + 0x0C, 0x34, 0x93, 0x10, 0xC3, 0x42, 0x80, 0x70, 0xFC, 0x0A, 0x48, 0x2F, 0x73, 0x18, 0x35, 0xE0, + 0x20, 0x48, 0xC2, 0x35, 0x05, 0xD1, 0x59, 0x89, 0x80, 0x00, 0x62, 0x52, 0xA4, 0xBE, 0x74, 0x9C, + 0xE7, 0xB8, 0x69, 0x97, 0xB5, 0xF1, 0xA3, 0x7E, 0x5C, 0xA6, 0x08, 0xC3, 0x96, 0x6C, 0x8D, 0xBA, + 0xDF, 0x6B, 0x50, 0x5A, 0xE5, 0x58, 0x27, 0xA9, 0xC7, 0x9D, 0x69, 0x4F, 0xC8, 0x8C, 0x4D, 0xE6, + 0xB9, 0xC8, 0xFF, 0x43, 0xD7, 0xFD, 0x6A, 0xDB, 0x3A, 0x15, 0x04, 0x0A, 0xCE, 0xCD, 0x8C, 0x70, + 0x80, 0x81, 0xCF, 0xD3, 0x90, 0x6F, 0x23, 0x56, 0xC9, 0xB4, 0x52, 0xCC, 0x91, 0x3F, 0xFD, 0xB9, + 0x6D, 0x0A, 0xA4, 0x94, 0x01, 0x22, 0x02, 0x24, 0x92, 0x41, 0x0A, 0x30, 0xF1, 0x51, 0xCE, 0x1C, + 0xC3, 0x97, 0x70, 0xC0, 0x83, 0xE8, 0xFD, 0xB9, 0x45, 0xBC, 0xCC, 0x85, 0x6D, 0x2B, 0x70, 0xE1, + 0xE8, 0x5A, 0xEC, 0x10, 0xB4, 0x34, 0x59, 0x66, 0x90, 0x2C, 0xC5, 0x4E, 0x38, 0x32, 0x06, 0x0C, + 0x08, 0xCC, 0x07, 0xC5, 0x54, 0xF2, 0x65, 0xAB, 0x5E, 0x83, 0x8A, 0x2A, 0xE1, 0x45, 0x80, 0x80, + 0x00, 0x04, 0x80, 0x03, 0x49, 0x28, 0xEC, 0xBF, 0xCC, 0xFC, 0xB4, 0xC9, 0x63, 0x19, 0x21, 0x38, + 0x20, 0xA8, 0x1F, 0x21, 0x6B, 0xE4, 0xC6, 0x72, 0xA1, 0x0A, 0xB4, 0x33, 0xEC, 0xE1, 0xD5, 0x6C, + 0x6E, 0xC6, 0x17, 0xA0, 0x26, 0x4F, 0x9F, 0x04, 0xD1, 0x6C, 0xE9, 0x4C, 0xFD, 0xB7, 0x57, 0x7E, + 0x9C, 0xAE, 0x59, 0xF8, 0xF3, 0x93, 0x56, 0xFE, 0x47, 0x13, 0x28, 0xFB, 0x78, 0x8F, 0xFD, 0x7C, + 0xD1, 0xF0, 0x8C, 0x7C, 0xF4, 0x11, 0xC6, 0xD5, 0xFF, 0xFB, 0x92, 0x64, 0xE0, 0x06, 0x04, 0x3F, + 0x30, 0xC9, 0x3B, 0x7A, 0x53, 0xD0, 0x2A, 0x64, 0x8A, 0x39, 0x04, 0x02, 0xA5, 0x90, 0xF8, 0xBD, + 0x24, 0x6E, 0x65, 0x4F, 0x40, 0xEE, 0x00, 0xEA, 0x74, 0x50, 0x88, 0x06, 0x15, 0xB1, 0x97, 0xD5, + 0xCC, 0x1C, 0x2C, 0x04, 0xC8, 0x69, 0x34, 0x47, 0x09, 0x33, 0xAE, 0xDE, 0xB0, 0x8D, 0x6C, 0xD0, + 0x96, 0xA4, 0xBD, 0x0A, 0xA7, 0x67, 0x2A, 0xC4, 0x31, 0x7F, 0xFA, 0x7B, 0xEA, 0xC0, 0x00, 0x00, + 0x0B, 0x1A, 0x10, 0x5A, 0xDA, 0x40, 0x46, 0x15, 0x70, 0xBA, 0xDB, 0xFF, 0x7D, 0xFF, 0x2D, 0xAB, + 0x89, 0xD8, 0x92, 0x40, 0xA1, 0xA6, 0xFF, 0xDA, 0xCF, 0xEF, 0x1F, 0x20, 0x54, 0x59, 0x91, 0x50, + 0x9D, 0x4A, 0xFF, 0x5B, 0xDA, 0x48, 0xBB, 0xA0, 0x90, 0x30, 0xC7, 0x20, 0x3C, 0xD4, 0x68, 0x34, + 0xD4, 0x41, 0x04, 0xC5, 0x52, 0x38, 0xD1, 0x68, 0x54, 0xE7, 0x6D, 0xD0, 0xE9, 0x90, 0x94, 0xCD, + 0xF1, 0x84, 0xC4, 0xD1, 0x5C, 0xE1, 0x25, 0x0C, 0xC6, 0x62, 0x24, 0xC0, 0x52, 0x68, 0xD9, 0x32, + 0x28, 0xCE, 0xC3, 0xC8, 0xC4, 0x81, 0x30, 0xC7, 0x74, 0xC8, 0x2F, 0x40, 0xF2, 0x41, 0x4D, 0x01, + 0xE3, 0xC1, 0x54, 0xC7, 0x5D, 0xB3, 0x4F, 0x0E, 0x02, 0x16, 0x6A, 0xA2, 0x4E, 0xD9, 0x32, 0x14, + 0x22, 0x5D, 0x05, 0x60, 0xC0, 0x42, 0xC5, 0x48, 0x17, 0x7C, 0x2A, 0x40, 0x04, 0x70, 0x23, 0x10, + 0xE8, 0x14, 0x76, 0x01, 0x38, 0x2F, 0xA1, 0x31, 0x18, 0x88, 0xE9, 0x33, 0x80, 0x92, 0xEA, 0xD6, + 0x32, 0x23, 0xC1, 0xC3, 0x8C, 0x98, 0x66, 0xB4, 0x60, 0x82, 0xA9, 0x88, 0x2B, 0x2B, 0xF2, 0xCF, + 0x3A, 0xE8, 0x96, 0x32, 0x22, 0x5C, 0x65, 0xF8, 0xB6, 0xCD, 0xD4, 0x49, 0xE2, 0xD3, 0x64, 0x3D, + 0x3F, 0xB9, 0x0F, 0xCD, 0xAA, 0xA6, 0xF8, 0x9D, 0xB1, 0xE2, 0x3D, 0x4C, 0xBA, 0x19, 0xEF, 0xFB, + 0x7A, 0xD6, 0x30, 0x54, 0x96, 0x89, 0x5A, 0x9D, 0x2A, 0x27, 0x78, 0xE8, 0x81, 0x65, 0x48, 0xC9, + 0xAE, 0x20, 0x1E, 0x80, 0xD9, 0x25, 0x29, 0x8B, 0xD7, 0x32, 0xB7, 0x80, 0x7F, 0xD7, 0xFB, 0x1F, + 0x00, 0x00, 0x90, 0xE6, 0x18, 0x87, 0xC2, 0xB6, 0xC7, 0x03, 0x82, 0x78, 0x9C, 0xE5, 0xA0, 0x2D, + 0xBF, 0xE4, 0x40, 0xB0, 0x56, 0x88, 0x62, 0xBB, 0x6F, 0xC9, 0x82, 0x02, 0x91, 0xC3, 0x5E, 0x88, + 0x68, 0x54, 0x40, 0x85, 0xB9, 0x62, 0x73, 0x1D, 0x66, 0xD9, 0x67, 0xFF, 0xDA, 0xB1, 0xCD, 0xBA, + 0xE9, 0x45, 0x35, 0x14, 0x0B, 0xB1, 0x88, 0x5A, 0xB6, 0x3C, 0x78, 0xB0, 0x41, 0xF0, 0x19, 0xD1, + 0xCB, 0x8A, 0x21, 0x80, 0x00, 0x00, 0x00, 0x59, 0x36, 0xFA, 0xB9, 0x29, 0x30, 0xB3, 0xF6, 0x5E, + 0x83, 0x40, 0x47, 0x44, 0x63, 0xC2, 0xEA, 0x0E, 0xCB, 0x61, 0x3F, 0xF0, 0xBC, 0x24, 0xA1, 0x03, + 0x78, 0xD5, 0xB0, 0x77, 0x8B, 0xA8, 0x10, 0x65, 0x1F, 0x6A, 0xF0, 0xC2, 0x83, 0x24, 0x0F, 0x65, + 0xC4, 0x03, 0xD4, 0xE5, 0x0A, 0x0E, 0x83, 0x62, 0x08, 0xD4, 0xFF, 0xFB, 0x92, 0x64, 0xE4, 0x00, + 0x43, 0x58, 0x32, 0xD0, 0x6B, 0x0C, 0x3C, 0xBC, 0x28, 0xC0, 0x2A, 0x29, 0x0C, 0x42, 0x01, 0x97, + 0x44, 0xCB, 0x14, 0x0E, 0xE9, 0xEF, 0x41, 0x0B, 0x89, 0x25, 0xDC, 0xC4, 0x8D, 0xC8, 0xB8, 0xE4, + 0xA2, 0x15, 0x09, 0xE8, 0x8C, 0xC5, 0xF4, 0xFD, 0x06, 0x34, 0x74, 0x73, 0x54, 0xB9, 0x91, 0x00, + 0xE9, 0xD9, 0x99, 0xDF, 0xBF, 0x31, 0x56, 0x5F, 0x80, 0x87, 0x85, 0x27, 0xCE, 0xE1, 0x92, 0xE1, + 0x84, 0x56, 0xEF, 0xFD, 0x7F, 0x23, 0xFF, 0xE4, 0x3F, 0xFF, 0xB3, 0xDB, 0x00, 0x00, 0x00, 0x40, + 0x04, 0x38, 0x25, 0xA1, 0x11, 0x7A, 0x0A, 0x4D, 0x9D, 0x82, 0x2B, 0xF1, 0x54, 0x2A, 0x8C, 0x34, + 0xEA, 0xE9, 0x7B, 0xF7, 0xFF, 0x57, 0x21, 0xCA, 0x9D, 0xDE, 0xCF, 0xF9, 0xDF, 0x3D, 0x0C, 0x58, + 0x70, 0x8B, 0x82, 0x82, 0x75, 0xB5, 0xD2, 0x2E, 0x7C, 0xF9, 0xAC, 0x5F, 0x03, 0xAA, 0x54, 0xC0, + 0x00, 0x03, 0x7B, 0xD2, 0x04, 0x15, 0x3C, 0x85, 0xF1, 0xA6, 0xE3, 0x26, 0x0C, 0x31, 0xF3, 0x03, + 0xD8, 0xC5, 0x32, 0x61, 0x73, 0x1F, 0x8A, 0x32, 0x24, 0x73, 0x36, 0xAB, 0x08, 0x97, 0x30, 0xF0, + 0x53, 0x12, 0x33, 0x38, 0x9F, 0x23, 0x2F, 0x18, 0x32, 0x88, 0x93, 0x85, 0xB3, 0x29, 0xA1, 0x61, + 0x4B, 0xE2, 0xC2, 0xCC, 0x60, 0x01, 0xA0, 0xA2, 0x99, 0x22, 0x50, 0x23, 0x23, 0x57, 0x03, 0xA9, + 0x99, 0x01, 0x34, 0xD6, 0x20, 0xA1, 0xAF, 0xFA, 0x3B, 0x21, 0x25, 0x0D, 0x56, 0x05, 0xB1, 0x2E, + 0xD2, 0xFC, 0xAC, 0x3C, 0x59, 0xF6, 0x42, 0x4B, 0xA6, 0xFC, 0x88, 0x85, 0x05, 0x04, 0xD1, 0x21, + 0x34, 0x8E, 0x21, 0x87, 0x34, 0xD2, 0xE2, 0x06, 0x46, 0x16, 0x0C, 0x7E, 0xAB, 0xBD, 0xCE, 0xE8, + 0x63, 0xF8, 0xF8, 0x4C, 0x2A, 0x48, 0x0E, 0x13, 0xC6, 0x48, 0x84, 0xEA, 0xFF, 0xFD, 0xFE, 0xF0, + 0x23, 0xBE, 0x00, 0xB1, 0x9F, 0xED, 0xD3, 0xD1, 0xD5, 0x80, 0x00, 0x00, 0xD4, 0x2C, 0x43, 0x22, + 0x48, 0x96, 0xAA, 0x0B, 0x22, 0x90, 0x6B, 0x11, 0xFA, 0xDE, 0xA4, 0xAC, 0xC3, 0x43, 0x08, 0xFF, + 0x14, 0xC3, 0xB3, 0x4C, 0xF9, 0xD7, 0x25, 0xCA, 0x58, 0x95, 0x5F, 0x5F, 0x6B, 0x8C, 0x03, 0xA2, + 0x59, 0xEE, 0xB6, 0xAD, 0xED, 0xB4, 0x51, 0xCE, 0xA2, 0x08, 0x07, 0x41, 0x64, 0x87, 0x47, 0xA8, + 0x40, 0x0E, 0x3D, 0x94, 0x2A, 0x00, 0x02, 0x12, 0x73, 0x2A, 0x61, 0x12, 0x00, 0x73, 0x40, 0x28, + 0xC8, 0x12, 0x16, 0x62, 0xE6, 0x87, 0x60, 0xF4, 0x6F, 0xE2, 0x66, 0x10, 0xD6, 0x60, 0x67, 0xE6, + 0x3D, 0x0C, 0x63, 0x87, 0x86, 0x12, 0x32, 0x02, 0x1E, 0x34, 0x4D, 0xD2, 0xFB, 0x9A, 0x90, 0x70, + 0x01, 0x40, 0x99, 0xA0, 0x7C, 0x3E, 0x8C, 0xAF, 0x02, 0x38, 0xA8, 0x21, 0x60, 0x83, 0x4C, 0xA7, + 0x6A, 0x8B, 0x0E, 0x2C, 0x06, 0x68, 0xC2, 0x90, 0x4E, 0xBC, 0x17, 0x33, 0x58, 0x22, 0xAC, 0x6D, + 0xF0, 0x8C, 0xB0, 0xA6, 0xEF, 0x46, 0xCC, 0x19, 0x43, 0x5D, 0xBA, 0x80, 0xFF, 0xFB, 0x92, 0x64, + 0xDA, 0x84, 0x03, 0x27, 0x21, 0x4C, 0x53, 0x58, 0x61, 0xD0, 0x33, 0xC1, 0x4A, 0x1D, 0x2C, 0x23, + 0x00, 0x91, 0x28, 0xC3, 0x20, 0x4D, 0xE5, 0x4F, 0x50, 0xED, 0x0D, 0x68, 0x24, 0x50, 0x0E, 0x4E, + 0x42, 0x86, 0xDE, 0xBD, 0xD7, 0xFE, 0x8D, 0x47, 0x32, 0x22, 0x84, 0x3A, 0xAC, 0xB9, 0xD2, 0x2F, + 0xBF, 0xE5, 0x15, 0x51, 0x50, 0x90, 0xB3, 0x89, 0xB5, 0x0A, 0xFF, 0x86, 0x3F, 0xAB, 0x7D, 0x69, + 0xF3, 0xAC, 0x7A, 0xD4, 0x2C, 0xFF, 0xD3, 0xBB, 0xEB, 0xC8, 0x00, 0x00, 0x00, 0xAD, 0xDB, 0x88, + 0xA4, 0xC7, 0x22, 0xB8, 0x1E, 0xA3, 0x96, 0xB2, 0x43, 0xFC, 0x3F, 0x57, 0x14, 0x96, 0x16, 0x02, + 0xB6, 0xFE, 0xD1, 0x00, 0x7C, 0x72, 0xAA, 0xF5, 0x76, 0xDE, 0x25, 0x83, 0x1B, 0x94, 0xE5, 0x18, + 0x5D, 0x40, 0xA0, 0x18, 0xA9, 0x04, 0xEC, 0x3E, 0x0E, 0x8E, 0x4A, 0x59, 0x52, 0x9F, 0x75, 0xA8, + 0x49, 0xE1, 0x62, 0xAB, 0x43, 0x96, 0xEA, 0xD7, 0x00, 0x01, 0x37, 0x58, 0x12, 0x8A, 0x98, 0x28, + 0x51, 0xAE, 0xAA, 0x99, 0x68, 0x30, 0x38, 0x24, 0xD1, 0x89, 0x8C, 0x42, 0x90, 0x70, 0x88, 0xCC, + 0x41, 0xC0, 0xC1, 0x86, 0x26, 0x36, 0xB2, 0x84, 0xA6, 0x0C, 0xB0, 0x10, 0xF4, 0xE6, 0x0C, 0xA0, + 0x44, 0x39, 0x04, 0x10, 0x50, 0x1D, 0x5E, 0xB1, 0x5F, 0xC9, 0x01, 0xD7, 0x2D, 0x6E, 0x58, 0xCD, + 0xC9, 0xBB, 0x85, 0x1B, 0x86, 0xCE, 0x64, 0xB1, 0x94, 0xB2, 0x62, 0xEB, 0xF9, 0x93, 0x22, 0xAB, + 0x79, 0x8D, 0x3B, 0x31, 0x89, 0xE0, 0xA3, 0x8D, 0x75, 0xE4, 0xA5, 0x41, 0xA6, 0xEA, 0xAD, 0x92, + 0x18, 0x94, 0xBC, 0xBD, 0xD8, 0xA0, 0xBC, 0x9D, 0x10, 0xB9, 0x1D, 0x4F, 0x38, 0x75, 0xF3, 0xD5, + 0x35, 0xDF, 0x92, 0x0F, 0xB9, 0xC4, 0x66, 0x54, 0x87, 0x42, 0xF9, 0xD5, 0x76, 0xE8, 0x46, 0x75, + 0xA3, 0xEA, 0x43, 0x54, 0xCE, 0xA6, 0x11, 0x42, 0x7D, 0x7F, 0x4F, 0x03, 0x22, 0x28, 0x12, 0xEE, + 0x21, 0x86, 0x96, 0x2D, 0x84, 0xDA, 0x90, 0x40, 0xD9, 0x7E, 0x25, 0x06, 0x46, 0xBF, 0x3E, 0x2C, + 0xD6, 0xE8, 0xA4, 0x96, 0x9F, 0xF4, 0x93, 0x65, 0x0F, 0x06, 0xC2, 0x0C, 0xCC, 0xDA, 0xE7, 0x2D, + 0x84, 0xD0, 0x95, 0xDD, 0x10, 0xAC, 0x45, 0x2E, 0x74, 0xFD, 0x63, 0xC5, 0x6C, 0x81, 0x65, 0x43, + 0xE8, 0x0D, 0xD5, 0x5C, 0x9D, 0x00, 0x01, 0x69, 0xA5, 0x1F, 0x30, 0xE0, 0x6C, 0xD2, 0x0F, 0x43, + 0x2B, 0x87, 0x40, 0xA3, 0x83, 0x16, 0xAE, 0x8C, 0x36, 0xAB, 0x01, 0x38, 0x0C, 0x0B, 0x0E, 0x31, + 0x99, 0x2C, 0x6A, 0xDA, 0x01, 0x0C, 0x99, 0xC5, 0x54, 0x71, 0x14, 0xE9, 0xF0, 0x25, 0x26, 0x41, + 0x0D, 0x85, 0x06, 0x86, 0x48, 0x26, 0x98, 0x64, 0x54, 0xFB, 0xA0, 0x40, 0x02, 0x08, 0x36, 0xF8, + 0x91, 0x3F, 0x03, 0x80, 0xA3, 0xAB, 0x84, 0x1B, 0x0B, 0xA8, 0xA6, 0x68, 0x00, 0x5B, 0xEA, 0x62, + 0x5B, 0x67, 0x91, 0x93, 0x8C, 0x2C, 0x5A, 0xE5, 0x59, 0x79, 0x47, 0xDA, 0xF4, 0x17, 0xFF, 0xFB, + 0x92, 0x64, 0xEA, 0x86, 0x64, 0x00, 0x30, 0xC9, 0x1B, 0x78, 0x2B, 0xD0, 0x3E, 0xE1, 0x49, 0xBA, + 0x08, 0xC9, 0x04, 0x10, 0x88, 0xC9, 0x25, 0x4D, 0xE0, 0xF1, 0x00, 0xE2, 0x06, 0x26, 0xF4, 0x17, + 0x98, 0x48, 0x46, 0xCE, 0x8B, 0x86, 0xDE, 0xAF, 0x53, 0x06, 0x52, 0xD3, 0xA9, 0x5B, 0x88, 0x9D, + 0xEB, 0x49, 0xAA, 0xDE, 0x03, 0xB8, 0x19, 0x31, 0x49, 0x8A, 0x67, 0x5C, 0xA5, 0x92, 0xAB, 0x26, + 0x56, 0x8F, 0x8F, 0xA6, 0x9F, 0xDD, 0xB9, 0x6B, 0xA3, 0xA6, 0x41, 0x79, 0x66, 0x39, 0x33, 0xDE, + 0x29, 0x75, 0xF4, 0xFA, 0x71, 0x5E, 0x2D, 0xE3, 0x13, 0x51, 0x7B, 0x63, 0xEC, 0xFF, 0xED, 0x50, + 0x84, 0x00, 0xA4, 0x9B, 0x82, 0xD0, 0xF4, 0x1B, 0x35, 0xDC, 0x9A, 0x08, 0x5C, 0xF7, 0xBD, 0x81, + 0x41, 0x87, 0x31, 0xCD, 0xFA, 0x5F, 0x17, 0x50, 0xC5, 0x73, 0x7E, 0x2E, 0xFF, 0xB6, 0xA3, 0x94, + 0xC4, 0x6D, 0x24, 0x6D, 0x6E, 0x16, 0x42, 0x56, 0x69, 0x7A, 0xF7, 0x97, 0xB9, 0xB2, 0xD2, 0xA4, + 0x62, 0x97, 0xA1, 0x0A, 0x0F, 0xB4, 0xD0, 0x00, 0x10, 0x54, 0x15, 0xA3, 0x22, 0x30, 0xC6, 0xB5, + 0x80, 0xB3, 0x73, 0x22, 0x1C, 0xD6, 0x87, 0x3E, 0xD4, 0x4D, 0x09, 0x63, 0x25, 0xA4, 0x44, 0x68, + 0xCC, 0x99, 0x4C, 0x83, 0x02, 0xD9, 0x83, 0x9E, 0x7D, 0xC6, 0xB4, 0x68, 0x63, 0x13, 0x0A, 0x8C, + 0x4C, 0x4A, 0x50, 0x3B, 0x45, 0xEA, 0x0E, 0x38, 0xBA, 0x60, 0x85, 0x4A, 0xA5, 0x16, 0x75, 0x24, + 0xCB, 0x80, 0xF5, 0x0C, 0x39, 0x11, 0x4A, 0xA1, 0x3A, 0x31, 0x55, 0xB1, 0xCB, 0x00, 0xF0, 0x4C, + 0x6D, 0x26, 0xCC, 0x3B, 0xD8, 0xC3, 0x90, 0x58, 0x90, 0x85, 0xE9, 0x22, 0x97, 0x88, 0x0C, 0x38, + 0xDA, 0x3C, 0xA0, 0x71, 0x73, 0xB5, 0x06, 0xA2, 0x5B, 0xE2, 0x1E, 0x28, 0x55, 0x81, 0x31, 0x2B, + 0xFF, 0xEF, 0xD1, 0xEA, 0xA3, 0x6E, 0x1A, 0x63, 0x0D, 0x2E, 0x44, 0xA8, 0x7E, 0x40, 0x00, 0x40, + 0x03, 0x92, 0x4A, 0x38, 0x0C, 0x5A, 0xA4, 0x96, 0x96, 0x33, 0x63, 0xA9, 0xE1, 0x70, 0x00, 0x0B, + 0xDD, 0xFF, 0x4F, 0x7C, 0xC1, 0xF4, 0x8F, 0x73, 0x62, 0x82, 0x90, 0x31, 0x00, 0xDB, 0xD2, 0x7D, + 0x2A, 0x22, 0x69, 0xF6, 0xFD, 0x04, 0x9C, 0xD3, 0x55, 0xA7, 0x9B, 0x8C, 0x2A, 0x42, 0xD6, 0xDF, + 0x62, 0x55, 0x80, 0x00, 0x00, 0x00, 0x9A, 0xB7, 0x7B, 0xB0, 0x63, 0x11, 0x04, 0xF6, 0x40, 0x00, + 0x84, 0x48, 0x51, 0x79, 0xC0, 0x8C, 0xAB, 0x40, 0xAC, 0x8C, 0x09, 0x73, 0x34, 0x01, 0x4D, 0x04, + 0x43, 0x09, 0x4C, 0x1C, 0x83, 0x4A, 0x18, 0x24, 0x2C, 0xC1, 0x92, 0x30, 0x41, 0x59, 0xF3, 0x90, + 0x22, 0xC1, 0x5A, 0xE9, 0x9C, 0xF6, 0x31, 0xDE, 0x28, 0xCE, 0xF4, 0xFB, 0x9B, 0x2C, 0x55, 0xDE, + 0xD0, 0xE0, 0x5F, 0x2B, 0x9A, 0xA4, 0x55, 0xAF, 0x38, 0x41, 0xD4, 0x04, 0x40, 0xD2, 0x1C, 0x28, + 0x35, 0x24, 0x2F, 0xE2, 0xC2, 0x6C, 0x5B, 0xF8, 0x44, 0x5D, 0x24, 0x6B, 0x9E, 0xA1, 0xA1, 0x86, + 0xFF, 0xFB, 0x92, 0x64, 0xEB, 0x8C, 0x04, 0xB5, 0x32, 0x47, 0x13, 0x99, 0x4C, 0xB0, 0x37, 0x01, + 0x59, 0xC7, 0x00, 0x69, 0x02, 0x8E, 0xC4, 0xC3, 0x26, 0x6D, 0x3C, 0x52, 0xC0, 0xD2, 0x04, 0xA8, + 0x68, 0x30, 0x8C, 0x8A, 0xDB, 0x61, 0x74, 0x0E, 0xA3, 0xC4, 0x0F, 0xA4, 0xF1, 0x45, 0x25, 0xEB, + 0x99, 0x59, 0x30, 0x19, 0x7B, 0x2B, 0xB0, 0x24, 0x95, 0x21, 0x11, 0x47, 0x0A, 0xEB, 0x63, 0xC7, + 0xFF, 0xC7, 0x53, 0x43, 0xDF, 0x52, 0xE0, 0x09, 0x01, 0x37, 0x2E, 0x17, 0x2D, 0x19, 0x19, 0xF2, + 0x77, 0xDB, 0xAE, 0x85, 0x3B, 0x91, 0xD4, 0xD6, 0xE8, 0xA1, 0x3E, 0x53, 0xB7, 0x7F, 0x98, 0x45, + 0x4A, 0x9C, 0x85, 0x23, 0x75, 0xBD, 0xE6, 0x1A, 0x01, 0x28, 0x2E, 0x27, 0x29, 0xBC, 0xD5, 0x99, + 0x34, 0xA4, 0xE5, 0x24, 0x18, 0xE1, 0x75, 0x00, 0x14, 0xA6, 0xAA, 0xDA, 0x51, 0x85, 0x5A, 0x95, + 0x94, 0x33, 0x3E, 0x9B, 0xE2, 0xE0, 0x00, 0x42, 0x4E, 0x5D, 0x91, 0x02, 0x44, 0x81, 0xD0, 0x21, + 0x9A, 0x80, 0x80, 0x63, 0x52, 0x32, 0x30, 0x6C, 0xE3, 0x3C, 0x21, 0x37, 0xA1, 0x71, 0x92, 0xE3, + 0x07, 0x34, 0x0B, 0xA7, 0x05, 0x97, 0x8D, 0x84, 0x14, 0xDC, 0xF0, 0x48, 0x9B, 0xCC, 0x54, 0x54, + 0x60, 0x82, 0x5A, 0x07, 0x1D, 0xF7, 0x53, 0x31, 0x4E, 0xA8, 0x33, 0x9E, 0xDC, 0x96, 0x74, 0x93, + 0x88, 0x09, 0x45, 0xB5, 0x43, 0x45, 0x30, 0xD8, 0xA4, 0x10, 0x09, 0xB0, 0x54, 0x4D, 0xF3, 0x73, + 0x4C, 0xFA, 0xCE, 0xDC, 0xD3, 0x35, 0xC9, 0xB9, 0xA5, 0x70, 0x5C, 0x4C, 0xEA, 0x38, 0xF1, 0xD2, + 0x8B, 0xCB, 0xB4, 0x18, 0xA0, 0x67, 0xFA, 0x20, 0xEA, 0x60, 0x45, 0x90, 0xAC, 0x1B, 0xA0, 0x8E, + 0x5C, 0xC7, 0x1F, 0x87, 0xB3, 0x0E, 0xA8, 0xFE, 0x96, 0x95, 0xBA, 0xB5, 0xB3, 0xAD, 0x7A, 0x52, + 0x2D, 0xDD, 0xA9, 0x2D, 0x24, 0xDD, 0x5F, 0xD5, 0xB3, 0xEA, 0x48, 0x40, 0x00, 0x09, 0x20, 0x13, + 0x4E, 0x40, 0x50, 0x55, 0x82, 0xCE, 0x7D, 0x39, 0x15, 0x3F, 0x58, 0x91, 0x42, 0x98, 0x20, 0x54, + 0x5C, 0x3A, 0x0D, 0x05, 0x98, 0xDF, 0x25, 0xC9, 0xBC, 0xC1, 0xF5, 0x15, 0x50, 0x70, 0xC9, 0x67, + 0x55, 0x67, 0xE6, 0x26, 0x07, 0xA6, 0xE5, 0xB9, 0x25, 0xCC, 0xCC, 0x13, 0xA9, 0x75, 0x1B, 0x6B, + 0xDE, 0x29, 0x0E, 0xD0, 0xDE, 0xC8, 0x5D, 0x00, 0x0D, 0x08, 0xD2, 0x3B, 0xA0, 0x9C, 0xD0, 0x6A, + 0x93, 0x3D, 0x02, 0x05, 0x83, 0x26, 0x61, 0x34, 0x1A, 0x9D, 0x18, 0x6C, 0x64, 0x09, 0xB3, 0xC5, + 0xC6, 0x20, 0x25, 0x98, 0xED, 0x32, 0x65, 0x10, 0x80, 0x18, 0x7E, 0x70, 0x33, 0x89, 0xAA, 0x7C, + 0x06, 0x32, 0x34, 0x83, 0x44, 0x84, 0x23, 0x9D, 0x2A, 0x11, 0x40, 0x16, 0x21, 0x0F, 0x4D, 0xD4, + 0x18, 0xD4, 0xB1, 0x09, 0x90, 0x5B, 0x80, 0x8E, 0xC5, 0x07, 0xA1, 0x15, 0x2C, 0xE0, 0x54, 0x10, + 0xB0, 0x11, 0x55, 0xC0, 0x3C, 0x0A, 0x96, 0xAD, 0x35, 0x34, 0x28, 0x11, 0x93, 0xC8, 0x9A, 0x33, + 0x5F, 0x89, 0xFF, 0xFB, 0x92, 0x64, 0xEE, 0x04, 0x04, 0x02, 0x30, 0xCB, 0x53, 0x4F, 0x2C, 0x40, + 0x3F, 0x22, 0x79, 0x87, 0x24, 0xC3, 0x1E, 0x10, 0x94, 0xC3, 0x24, 0x6D, 0xE0, 0x6F, 0x40, 0xF3, + 0x06, 0xE7, 0x74, 0x33, 0x09, 0x42, 0xB3, 0x64, 0x24, 0x91, 0x86, 0x89, 0xEE, 0x12, 0x2B, 0x5A, + 0x00, 0x06, 0x7C, 0xA8, 0x3F, 0x26, 0x24, 0xFC, 0xBB, 0xCF, 0x1D, 0xD0, 0xB3, 0xA9, 0xEA, 0x57, + 0x71, 0xC0, 0x78, 0x36, 0x49, 0x69, 0xEC, 0x3C, 0x10, 0x18, 0x70, 0x9C, 0x26, 0x1D, 0x61, 0x43, + 0x2E, 0x36, 0x9F, 0xA7, 0xBD, 0xFA, 0x40, 0x0B, 0x80, 0x1B, 0x60, 0x45, 0x45, 0xDC, 0x40, 0x47, + 0x9B, 0x76, 0x18, 0x63, 0xC0, 0x86, 0xDB, 0x63, 0x52, 0x36, 0x86, 0x11, 0xF3, 0xDF, 0x4F, 0xD5, + 0x5C, 0xBA, 0x38, 0x28, 0x5C, 0x4B, 0xEF, 0x4B, 0x46, 0xA8, 0x12, 0x1A, 0x9F, 0xFA, 0x6F, 0x8E, + 0x98, 0x63, 0x62, 0x00, 0xE3, 0x50, 0x50, 0x79, 0xC4, 0x18, 0x25, 0x9D, 0xCF, 0x3C, 0x73, 0xC3, + 0x22, 0xEA, 0x56, 0x1B, 0x36, 0xE1, 0xA4, 0x19, 0x30, 0xA8, 0xC4, 0xC5, 0x43, 0x40, 0xC1, 0x20, + 0xD0, 0x14, 0x90, 0x28, 0x60, 0x48, 0x89, 0x9B, 0x84, 0x26, 0x50, 0x0C, 0x36, 0x86, 0x62, 0x46, + 0x18, 0xAC, 0x64, 0x4C, 0x21, 0x31, 0x88, 0xE8, 0xE7, 0x8C, 0x90, 0x31, 0xA0, 0x0C, 0x5F, 0x10, + 0xDE, 0x10, 0xE3, 0xB6, 0x99, 0x40, 0x82, 0x91, 0xB4, 0xBC, 0x90, 0x3A, 0xE8, 0x4A, 0x1D, 0x31, + 0x90, 0x40, 0x2E, 0x84, 0x67, 0x6D, 0x65, 0x42, 0xDB, 0x9A, 0x8B, 0x30, 0x66, 0x20, 0xEB, 0x44, + 0xDB, 0xA4, 0xBE, 0x72, 0x3D, 0x72, 0x5F, 0x2D, 0x43, 0xAA, 0x11, 0xB5, 0x28, 0x44, 0x17, 0x40, + 0x0A, 0x7F, 0xE0, 0x5C, 0x3B, 0x16, 0xBF, 0xF6, 0xE7, 0x5E, 0xE9, 0x7E, 0x06, 0x32, 0x25, 0x95, + 0x68, 0x4E, 0x1C, 0xBA, 0xA2, 0xC5, 0x9C, 0xB1, 0xFF, 0x47, 0xFF, 0xFF, 0xBF, 0xFF, 0xF5, 0xD6, + 0x00, 0x03, 0x58, 0xAF, 0xC0, 0x8F, 0xAB, 0x6C, 0xAB, 0xF3, 0x16, 0xE1, 0x2D, 0xF5, 0x4B, 0x28, + 0x9C, 0xB7, 0xD6, 0xCF, 0x95, 0x3D, 0xD7, 0xD5, 0xC8, 0xB5, 0xE5, 0x61, 0x43, 0x8D, 0x9E, 0x97, + 0x70, 0x6E, 0xB2, 0x35, 0xB5, 0x67, 0xE3, 0x5F, 0x4A, 0x15, 0x5B, 0x0B, 0xBC, 0x5C, 0x58, 0x04, + 0x23, 0x0D, 0x5F, 0x11, 0x89, 0xCD, 0x28, 0x22, 0x01, 0xAF, 0x21, 0x3C, 0xCA, 0x08, 0x53, 0x32, + 0x81, 0xCC, 0x78, 0x0E, 0x30, 0x38, 0x0C, 0x40, 0xA7, 0x39, 0x91, 0xF8, 0xC1, 0xCA, 0x73, 0x49, + 0x8B, 0x8C, 0x32, 0x46, 0x35, 0xF9, 0xDC, 0xCC, 0x05, 0x53, 0x10, 0x8B, 0x4D, 0x08, 0x3A, 0x13, + 0xF7, 0x18, 0x7C, 0x2C, 0x64, 0xD0, 0xA9, 0x80, 0x85, 0x03, 0x02, 0x31, 0x60, 0x60, 0x10, 0x84, + 0x3A, 0xF0, 0x36, 0x84, 0x27, 0x76, 0x0B, 0xAC, 0x00, 0x70, 0x88, 0x76, 0x47, 0x40, 0x85, 0x92, + 0xA6, 0x91, 0x0C, 0x8B, 0x09, 0xB7, 0x14, 0x32, 0x2C, 0x35, 0x97, 0x1C, 0xB6, 0x6B, 0x9E, 0x5A, + 0xB2, 0x60, 0x25, 0x2A, 0xFF, 0xFB, 0x92, 0x64, 0xEC, 0x8E, 0x84, 0x5A, 0x30, 0xC7, 0x93, 0x99, + 0x3B, 0xD0, 0x3D, 0xC3, 0x69, 0xAD, 0x00, 0x67, 0x1E, 0x0F, 0x64, 0xB1, 0x24, 0x4E, 0x65, 0x0F, + 0x40, 0xE3, 0x0D, 0x64, 0xE4, 0x20, 0x1C, 0xC8, 0x8B, 0x38, 0x03, 0x89, 0x6C, 0x6A, 0x05, 0x21, + 0x8C, 0x3E, 0xA0, 0x0C, 0x91, 0x32, 0xF9, 0x1E, 0x40, 0x5A, 0xEA, 0x3E, 0x4B, 0x6E, 0x76, 0x2F, + 0x27, 0x52, 0xBD, 0x23, 0x8D, 0xD4, 0xB8, 0xB7, 0x2A, 0xAD, 0x13, 0xD7, 0xDA, 0x76, 0x8B, 0x66, + 0xB6, 0x25, 0x8D, 0x53, 0xCF, 0xE2, 0xD0, 0x52, 0x28, 0x7A, 0x9A, 0x13, 0xF1, 0x54, 0x00, 0x8A, + 0x8A, 0x00, 0x00, 0x0D, 0x96, 0xE8, 0xAE, 0x3E, 0x8D, 0xE8, 0xD9, 0x60, 0x47, 0x51, 0xF6, 0xDC, + 0x18, 0xF4, 0xCE, 0xEA, 0xD1, 0x31, 0x71, 0xCA, 0xFE, 0xA3, 0x88, 0x31, 0x01, 0x80, 0x43, 0x46, + 0x2A, 0xA0, 0x65, 0x6B, 0xB8, 0x5F, 0xF6, 0x38, 0x86, 0xE6, 0xBC, 0xAB, 0x21, 0x47, 0x8C, 0x81, + 0x9F, 0xBA, 0x54, 0xC4, 0x50, 0x4A, 0xF3, 0x65, 0x82, 0x84, 0xD4, 0x58, 0x90, 0x20, 0x88, 0x00, + 0x00, 0x04, 0x52, 0x82, 0x0E, 0x6E, 0xC2, 0x22, 0xA0, 0xCF, 0x41, 0x63, 0x53, 0x0B, 0x17, 0x31, + 0x82, 0x33, 0x50, 0xC4, 0x12, 0x41, 0x30, 0x60, 0x43, 0x0C, 0x16, 0x36, 0x20, 0x23, 0x1D, 0x27, + 0x31, 0xC1, 0x53, 0x37, 0x12, 0x3C, 0x23, 0xA8, 0x51, 0x82, 0x8F, 0x02, 0x03, 0xC0, 0x48, 0x0A, + 0x95, 0x01, 0xD2, 0x01, 0x61, 0xC8, 0xE3, 0x4E, 0x73, 0x31, 0xC5, 0xB9, 0x4C, 0x07, 0x50, 0x6E, + 0xD8, 0xE2, 0x2A, 0x90, 0xE7, 0x22, 0x7C, 0x3D, 0x26, 0x71, 0x37, 0x28, 0x0C, 0x8B, 0xAE, 0x9B, + 0x11, 0x38, 0x6D, 0x6E, 0x17, 0xA6, 0xAA, 0xFA, 0x38, 0xFD, 0x39, 0x00, 0x26, 0xEC, 0x5B, 0xF3, + 0x6A, 0x88, 0xE6, 0x77, 0x93, 0xF8, 0x58, 0x8A, 0x45, 0x5E, 0x8D, 0x5F, 0x67, 0xFD, 0x1E, 0xB2, + 0x6F, 0x3E, 0x79, 0xEE, 0x9D, 0xCA, 0xAC, 0x63, 0x80, 0x00, 0x00, 0x10, 0x02, 0x30, 0xBB, 0x88, + 0xE9, 0xBF, 0x4C, 0x8B, 0xA0, 0x84, 0x9D, 0x0E, 0x67, 0xA6, 0xF4, 0x01, 0x05, 0x83, 0xA9, 0x1E, + 0x82, 0xC4, 0xDA, 0x9F, 0xCC, 0x3A, 0xE7, 0x03, 0x1F, 0xF9, 0x85, 0x12, 0x26, 0x43, 0x78, 0xA0, + 0x78, 0x6A, 0xAE, 0x96, 0x39, 0x3B, 0xC2, 0x8F, 0x54, 0x51, 0x8D, 0xA1, 0xCA, 0x4A, 0xAA, 0x84, + 0x00, 0x00, 0x00, 0x08, 0xB6, 0xF8, 0xF4, 0x79, 0xD6, 0x32, 0xF2, 0x90, 0xE2, 0xD0, 0x70, 0x18, + 0x88, 0x20, 0xD1, 0xE0, 0x46, 0xA2, 0x0C, 0x44, 0x31, 0x13, 0x4C, 0x74, 0x25, 0xA6, 0x3F, 0xE6, + 0x6C, 0x1A, 0x6B, 0x63, 0x6A, 0x18, 0x61, 0x23, 0x43, 0x41, 0xCC, 0xB6, 0x50, 0xD3, 0x53, 0xE0, + 0x67, 0x78, 0x8A, 0x71, 0x07, 0xBB, 0x4A, 0x50, 0x29, 0x5A, 0x59, 0x1C, 0x98, 0x14, 0xB0, 0xC9, + 0x99, 0x6F, 0x80, 0xB0, 0xC1, 0x06, 0x8D, 0xB1, 0xD5, 0x76, 0x84, 0xF8, 0xB1, 0x32, 0xED, 0xAA, + 0x47, 0x85, 0x6D, 0x05, 0x37, 0xFF, 0xFF, 0xFB, 0x92, 0x64, 0xED, 0x04, 0x04, 0x91, 0x2F, 0xC7, + 0x0B, 0x98, 0x5C, 0x40, 0x40, 0x63, 0x09, 0x6D, 0x0C, 0x25, 0x1A, 0x0F, 0x24, 0xBB, 0x27, 0x4D, + 0xBC, 0xB2, 0xC0, 0xDA, 0x87, 0xE6, 0xF4, 0x30, 0x0D, 0x80, 0xEF, 0x23, 0xFE, 0x50, 0x16, 0x82, + 0x7C, 0xAA, 0xD6, 0xD4, 0xF1, 0x53, 0xEF, 0x39, 0x33, 0x91, 0xF1, 0x6A, 0x3E, 0x7B, 0xF3, 0x3F, + 0x6A, 0xBD, 0x77, 0x98, 0x00, 0x0C, 0x8B, 0x0A, 0x8B, 0x6A, 0xE0, 0xBE, 0xC6, 0x2F, 0x55, 0x6F, + 0xED, 0x28, 0x24, 0x58, 0x78, 0x08, 0x78, 0x26, 0xC9, 0x18, 0x68, 0xB9, 0x33, 0x99, 0x2F, 0x0B, + 0x82, 0x20, 0xF0, 0xC1, 0x77, 0x17, 0xFF, 0x40, 0x64, 0xCB, 0xB8, 0x3C, 0xD5, 0x3C, 0x4C, 0x48, + 0x69, 0x84, 0x1D, 0x03, 0x15, 0x19, 0x6A, 0x21, 0xB5, 0x3A, 0x41, 0x99, 0xCB, 0xA1, 0xE1, 0xC0, + 0x40, 0xC4, 0x00, 0xD8, 0xC8, 0x54, 0x34, 0xC4, 0x10, 0xD4, 0xC2, 0x00, 0x44, 0x20, 0xED, 0x32, + 0xF3, 0x7B, 0x33, 0xCC, 0x1B, 0x36, 0x38, 0x71, 0x0A, 0x89, 0x26, 0x6D, 0x08, 0xC6, 0x26, 0x82, + 0xC6, 0x01, 0x82, 0xE6, 0x1D, 0x89, 0x06, 0xCC, 0x29, 0x03, 0x41, 0xA8, 0x61, 0xDE, 0x62, 0x18, + 0x86, 0x10, 0xBF, 0x23, 0x01, 0x87, 0x41, 0x40, 0x00, 0x2B, 0x03, 0x17, 0xC9, 0xF4, 0x8F, 0xC8, + 0x70, 0x05, 0x6C, 0x9C, 0x42, 0xC2, 0x98, 0x89, 0xA9, 0xB8, 0x61, 0x2D, 0x79, 0x30, 0x0B, 0x9C, + 0xD8, 0x02, 0xD9, 0x9A, 0xC9, 0x30, 0x84, 0xF8, 0x4A, 0xA4, 0xFA, 0xB0, 0x5A, 0xB7, 0xDC, 0x02, + 0x12, 0xCB, 0x4F, 0xB2, 0xA3, 0x2A, 0xE8, 0x1C, 0x4C, 0x69, 0x83, 0xA4, 0x30, 0xC2, 0x07, 0x3F, + 0xCF, 0x80, 0x81, 0x52, 0xB4, 0xAD, 0xFB, 0x3E, 0x66, 0x67, 0x7E, 0x75, 0x64, 0x05, 0xB7, 0x36, + 0xDB, 0x7D, 0xB8, 0x96, 0x21, 0x44, 0xD9, 0xC9, 0xD0, 0x48, 0x1D, 0xB4, 0xA7, 0x14, 0x5B, 0x96, + 0x39, 0xA8, 0x26, 0x89, 0xF6, 0x5F, 0xDD, 0xD8, 0x62, 0xE2, 0x01, 0x89, 0xCA, 0x21, 0x38, 0x1B, + 0x0B, 0x85, 0x45, 0x75, 0x40, 0x45, 0x69, 0x59, 0x30, 0x83, 0x0C, 0x8E, 0x5D, 0xD1, 0x55, 0xC8, + 0x4C, 0x15, 0x28, 0x75, 0xF8, 0xC2, 0x03, 0x14, 0xBE, 0x86, 0x1B, 0x50, 0x49, 0xD4, 0xBC, 0x5D, + 0x9A, 0xCB, 0x3E, 0xB9, 0x99, 0x05, 0x31, 0xE5, 0xAD, 0xB0, 0x08, 0xB1, 0x29, 0x77, 0x9E, 0x38, + 0xB5, 0x90, 0x14, 0x81, 0x33, 0xB6, 0x94, 0x6D, 0x68, 0x5A, 0x6A, 0x00, 0x06, 0x89, 0x73, 0x18, + 0x30, 0xF8, 0xE4, 0xC3, 0xA7, 0x12, 0x26, 0x38, 0x90, 0xA0, 0x30, 0x72, 0x60, 0xA8, 0x31, 0xAB, + 0xC0, 0x84, 0x55, 0x23, 0x0F, 0x02, 0x4C, 0xA2, 0x26, 0x30, 0x88, 0x9D, 0x2D, 0x09, 0x9C, 0x26, + 0x19, 0x4A, 0x81, 0x88, 0xAE, 0xA8, 0x04, 0x5E, 0x8E, 0x45, 0xCA, 0x43, 0x90, 0xB0, 0x58, 0x89, + 0x49, 0x09, 0x6E, 0x69, 0xF4, 0x8B, 0x6F, 0x4A, 0x7E, 0x2A, 0x84, 0xD2, 0x97, 0x02, 0x0A, 0xAF, + 0x58, 0x48, 0xA8, 0x49, 0x3A, 0xC9, 0xEC, 0xA5, 0xFF, 0xFB, 0x92, 0x64, 0xEA, 0x84, 0x03, 0x81, + 0x2E, 0xCB, 0x53, 0x6F, 0x14, 0x40, 0x3A, 0x21, 0xD9, 0xE9, 0x00, 0x23, 0x01, 0x93, 0x88, 0xBD, + 0x18, 0x0E, 0xE5, 0x92, 0xC1, 0x03, 0x0C, 0xA5, 0x8C, 0x33, 0x09, 0x58, 0x7E, 0x94, 0x34, 0x20, + 0x9D, 0x82, 0x04, 0x3B, 0x40, 0xA0, 0xBA, 0xB3, 0x59, 0x9A, 0xC1, 0x20, 0xCA, 0x87, 0x01, 0xD8, + 0xCD, 0xAF, 0xFE, 0xB3, 0x16, 0x8A, 0xD1, 0xA1, 0xF0, 0xF3, 0x90, 0xE3, 0x0C, 0x9C, 0xFF, 0xDD, + 0x56, 0xBD, 0x49, 0xFF, 0xFA, 0x66, 0xED, 0x00, 0x00, 0x40, 0x06, 0x1B, 0x83, 0x13, 0x84, 0xA0, + 0x6A, 0x6A, 0xF7, 0x06, 0x42, 0x44, 0x0E, 0x10, 0xCA, 0xDC, 0xEC, 0x1C, 0x34, 0x73, 0x4E, 0xC7, + 0x7F, 0x9E, 0x24, 0xE9, 0xDB, 0x7F, 0xD3, 0x49, 0xB5, 0x3D, 0x26, 0xC6, 0x24, 0xAB, 0xFB, 0x58, + 0x28, 0xD9, 0xE5, 0xB2, 0xD6, 0x59, 0x62, 0x50, 0x25, 0x15, 0x03, 0x0E, 0x95, 0x60, 0x0C, 0x5C, + 0xF5, 0x30, 0xF4, 0xC4, 0xDD, 0x60, 0x83, 0x00, 0x09, 0x8C, 0x3E, 0x75, 0x3C, 0x3C, 0x18, 0xC6, + 0x26, 0x43, 0x36, 0x26, 0xDC, 0xE3, 0x1A, 0x18, 0xCC, 0x34, 0x1B, 0x14, 0x31, 0x9A, 0x6C, 0x48, + 0x6A, 0x88, 0xB1, 0x83, 0xCB, 0x46, 0x3F, 0x14, 0x96, 0x02, 0xE6, 0xB0, 0x0D, 0x01, 0x80, 0xA8, + 0x49, 0x43, 0xA1, 0x95, 0x05, 0xA8, 0xE0, 0xAA, 0x84, 0x2C, 0x80, 0x80, 0x67, 0x2E, 0xF2, 0x61, + 0xA9, 0x8B, 0x27, 0x5A, 0xE2, 0x30, 0x1C, 0xB2, 0xFE, 0x8E, 0x10, 0x50, 0x7A, 0x7C, 0x31, 0x87, + 0x51, 0x95, 0x4F, 0xB8, 0x6A, 0x2C, 0x97, 0x2C, 0x35, 0xA9, 0x0C, 0x94, 0x03, 0x96, 0x04, 0xE4, + 0x33, 0x12, 0xB5, 0x2E, 0x7B, 0x3F, 0x55, 0xE3, 0xED, 0x0A, 0x41, 0x25, 0x87, 0xF8, 0xB4, 0xFE, + 0x88, 0xE7, 0x55, 0x97, 0x13, 0x86, 0x05, 0x27, 0x05, 0x8E, 0x00, 0xD1, 0x38, 0x0F, 0x17, 0x3B, + 0x55, 0x17, 0xF5, 0x7E, 0x95, 0x8D, 0x7F, 0x7C, 0x92, 0x50, 0xA5, 0xE3, 0xDA, 0xCF, 0xFE, 0x8C, + 0x49, 0x01, 0x08, 0x09, 0xA6, 0xE0, 0x15, 0x80, 0x7B, 0xD6, 0x05, 0x1F, 0x33, 0x9C, 0x3E, 0xE1, + 0x02, 0x21, 0xCC, 0xEC, 0xDB, 0x5A, 0x3C, 0xE1, 0xCD, 0x39, 0x9D, 0xA5, 0x8F, 0x42, 0xEE, 0x79, + 0x51, 0x8D, 0x1C, 0x65, 0x85, 0xDD, 0x5B, 0xDE, 0xDA, 0xC7, 0x8A, 0x8D, 0x00, 0xCB, 0xA1, 0x08, + 0x9A, 0x4D, 0xD8, 0xB8, 0xEA, 0x5A, 0x71, 0xC8, 0x43, 0x13, 0xA1, 0xC3, 0xAB, 0x3E, 0x8A, 0x01, + 0xA7, 0x60, 0xD3, 0x01, 0x85, 0x0D, 0xF9, 0x38, 0x32, 0x58, 0x09, 0x4D, 0x0C, 0x2E, 0x89, 0x31, + 0x9B, 0x6C, 0x00, 0x33, 0x31, 0x39, 0xD8, 0xC0, 0x21, 0xB3, 0x29, 0x12, 0xCC, 0x0A, 0x17, 0x0C, + 0x09, 0x18, 0xAC, 0x42, 0x69, 0x32, 0xD9, 0x80, 0x43, 0x85, 0xC9, 0x3A, 0xA8, 0x3F, 0x0D, 0x6C, + 0xE2, 0x00, 0xD1, 0xA0, 0x21, 0xC6, 0x51, 0x29, 0x2C, 0x12, 0x5D, 0x18, 0x31, 0xEB, 0x56, 0x08, + 0x79, 0x5F, 0x32, 0xC6, 0xBA, 0xAA, 0x8C, 0x29, 0xC0, 0x2B, 0xFF, 0xFB, 0x92, 0x64, 0xE5, 0x8E, + 0x03, 0xBA, 0x2F, 0x48, 0x93, 0x8F, 0x2D, 0x20, 0x34, 0xE1, 0x39, 0xCA, 0x30, 0x03, 0x32, 0x92, + 0x8C, 0xC3, 0x1A, 0x2E, 0x64, 0xF3, 0x00, 0xFC, 0x07, 0xE6, 0xE8, 0x93, 0x08, 0x0A, 0x15, 0xD4, + 0x6E, 0x94, 0x4D, 0x3F, 0x16, 0x0C, 0xC8, 0x1F, 0xB8, 0x3A, 0x20, 0x9D, 0x41, 0xC3, 0xBE, 0x76, + 0x62, 0x36, 0x63, 0xA0, 0xCD, 0x40, 0xC1, 0xA8, 0xE1, 0x51, 0x15, 0x71, 0xF7, 0xFF, 0x4F, 0xEA, + 0x68, 0xE4, 0x7C, 0xC7, 0x1A, 0x08, 0xC3, 0x5F, 0xFD, 0x2A, 0xD6, 0x37, 0xF4, 0x7E, 0xBC, 0x40, + 0x02, 0x00, 0x02, 0x06, 0xE0, 0x11, 0xC2, 0x75, 0xE6, 0xBE, 0xC7, 0x4D, 0x69, 0x09, 0xCE, 0x4C, + 0x63, 0xB9, 0x11, 0x69, 0xE9, 0x4E, 0x9D, 0xB5, 0xE6, 0x87, 0x76, 0x23, 0x09, 0xFF, 0xA8, 0x0C, + 0xDD, 0x05, 0x3B, 0xD7, 0xC5, 0xD2, 0xB6, 0x2E, 0x8A, 0xD6, 0x2A, 0x38, 0x06, 0xAE, 0x91, 0xD2, + 0x85, 0x40, 0xA6, 0x1E, 0x17, 0x1B, 0xAC, 0x80, 0x18, 0x0E, 0x30, 0x50, 0x40, 0xC1, 0x44, 0xF3, + 0x5F, 0x44, 0x4E, 0x6A, 0x54, 0x36, 0x01, 0x44, 0xC3, 0x42, 0x73, 0x24, 0xBE, 0x81, 0x86, 0x20, + 0x30, 0xDC, 0xDD, 0x22, 0x72, 0xD2, 0x19, 0x54, 0x8C, 0x60, 0x56, 0x09, 0xA1, 0xCE, 0x06, 0x7B, + 0x09, 0xA2, 0xF8, 0x00, 0x96, 0xA0, 0x86, 0x2D, 0xF2, 0xF0, 0x30, 0x4C, 0x2C, 0x9A, 0xE1, 0xD1, + 0x1F, 0x51, 0x59, 0xDB, 0x84, 0x45, 0xC8, 0x11, 0x12, 0xBD, 0x19, 0xFA, 0x51, 0x06, 0x16, 0x91, + 0x2C, 0xB5, 0x5D, 0xAA, 0xCB, 0x69, 0x36, 0xB2, 0x44, 0x40, 0x3A, 0x2F, 0xCA, 0x02, 0x0C, 0x73, + 0x92, 0xF2, 0x19, 0x51, 0x16, 0xD3, 0x5B, 0x6A, 0x3F, 0xFB, 0x7E, 0xDA, 0x7B, 0x83, 0x8B, 0x93, + 0x16, 0x9C, 0x0B, 0x09, 0x21, 0xE9, 0x46, 0x5D, 0x3D, 0xAC, 0xC3, 0x27, 0x22, 0x30, 0xF3, 0x14, + 0x0A, 0x3C, 0x10, 0x2D, 0x22, 0xF2, 0x4D, 0xAC, 0x6F, 0x44, 0x72, 0x3B, 0x57, 0x62, 0xC5, 0x1C, + 0xC4, 0x11, 0xA8, 0x0A, 0x04, 0xFF, 0xF6, 0xFA, 0x39, 0x0C, 0x06, 0x00, 0xE5, 0x82, 0x85, 0x35, + 0x5F, 0xB1, 0x88, 0x92, 0xDD, 0x4C, 0xD6, 0x29, 0x35, 0x1D, 0x0E, 0x46, 0x5D, 0xF7, 0xFC, 0x28, + 0x27, 0x09, 0x92, 0x39, 0x10, 0x2A, 0x68, 0x09, 0x6A, 0x5E, 0x35, 0xE3, 0xDA, 0x10, 0x9F, 0x2A, + 0x18, 0x25, 0x3C, 0x0A, 0x4D, 0xA6, 0xA3, 0x97, 0xBF, 0xAE, 0xB5, 0x93, 0x09, 0xBA, 0xB2, 0xD4, + 0x0A, 0x8A, 0x87, 0xEA, 0x00, 0x4E, 0xCB, 0xB2, 0x92, 0xA8, 0x38, 0xC6, 0x21, 0x91, 0x24, 0xF8, + 0x24, 0x2E, 0x60, 0x32, 0xD9, 0x52, 0x20, 0x60, 0xC0, 0xE1, 0x80, 0x83, 0x86, 0x16, 0x0C, 0x99, + 0xB0, 0x6E, 0x62, 0x89, 0x19, 0x89, 0xA1, 0x2B, 0xCC, 0x2F, 0x81, 0x0B, 0x23, 0x22, 0x08, 0x38, + 0x18, 0x64, 0xA8, 0xE2, 0xF1, 0x31, 0xE3, 0x4D, 0x58, 0x47, 0xF6, 0x71, 0xD3, 0x46, 0x3A, 0xD0, + 0x5A, 0x47, 0xB6, 0x8D, 0xA3, 0x66, 0x61, 0x4F, 0xAE, 0x9E, 0x34, 0x6A, 0xFF, 0xFB, 0x92, 0x64, + 0xE4, 0x8E, 0x03, 0xDC, 0x31, 0x48, 0x0B, 0x99, 0x3B, 0xD0, 0x30, 0x05, 0x09, 0xDA, 0x28, 0x03, + 0xB4, 0x93, 0x38, 0xC3, 0x18, 0x2E, 0x64, 0xF1, 0x40, 0xEC, 0x13, 0xE8, 0x24, 0x20, 0x0F, 0x0E, + 0x6B, 0xCD, 0x89, 0x5C, 0x33, 0xA9, 0x87, 0xCE, 0x21, 0x28, 0x62, 0x32, 0xC7, 0x6C, 0x21, 0x5B, + 0xEF, 0xD8, 0x8C, 0x21, 0x82, 0x60, 0xB8, 0xD0, 0xFA, 0x8A, 0x18, 0x73, 0xD0, 0x59, 0x8E, 0x4E, + 0x20, 0x9F, 0xCE, 0x7C, 0x3A, 0x18, 0x5C, 0x22, 0x15, 0x28, 0x75, 0x2E, 0x63, 0xD2, 0x93, 0xB5, + 0xCA, 0xBB, 0x7F, 0x39, 0xC8, 0xA8, 0xE5, 0x97, 0x50, 0x84, 0x42, 0x00, 0x00, 0x39, 0x56, 0x24, + 0x19, 0x9D, 0x8A, 0x84, 0xC3, 0x31, 0x74, 0xD2, 0xEF, 0x24, 0xC7, 0x21, 0x2F, 0x30, 0x3D, 0xFD, + 0x35, 0xB1, 0xCF, 0x7A, 0x0E, 0xAE, 0x1B, 0x24, 0x8B, 0x19, 0x60, 0x89, 0xE5, 0x1E, 0x74, 0xFD, + 0x5F, 0xD6, 0xCE, 0x98, 0xD8, 0xC3, 0x17, 0x11, 0x4A, 0x55, 0xDD, 0x80, 0x00, 0x02, 0xDF, 0xB7, + 0xD7, 0x86, 0x59, 0xF0, 0x10, 0x01, 0xF0, 0xD1, 0xF8, 0xC2, 0x9C, 0xD1, 0x2C, 0x3E, 0x53, 0x1D, + 0x71, 0x18, 0x80, 0xD4, 0x00, 0xC1, 0x8E, 0x02, 0x18, 0xC9, 0x9B, 0x88, 0x04, 0x20, 0x33, 0x6B, + 0x35, 0x22, 0xA5, 0xEE, 0xB0, 0x8C, 0x36, 0x83, 0x11, 0x8A, 0x07, 0x23, 0x38, 0xCD, 0x07, 0x54, + 0x25, 0x86, 0x6A, 0x87, 0x48, 0x44, 0xD5, 0x44, 0x38, 0xE1, 0x37, 0xAF, 0xD8, 0xB7, 0x59, 0x2E, + 0x85, 0x43, 0xB5, 0x39, 0x79, 0xA9, 0x50, 0xF8, 0x44, 0x26, 0x05, 0xFA, 0x92, 0x19, 0x7C, 0x5F, + 0xFF, 0x2B, 0x23, 0xCA, 0x04, 0x49, 0x08, 0x61, 0x43, 0xDC, 0x78, 0x90, 0x09, 0x47, 0xA3, 0xD4, + 0x69, 0x7E, 0x88, 0xB2, 0x6F, 0x50, 0xD5, 0xA1, 0x74, 0x38, 0x57, 0xA7, 0xF6, 0xAF, 0xD6, 0xBF, + 0x56, 0x08, 0x20, 0x21, 0xBF, 0xAF, 0xDC, 0x5B, 0x8A, 0x35, 0x50, 0x36, 0xB4, 0x3A, 0x49, 0x93, + 0xD7, 0xB7, 0x54, 0x7F, 0xE7, 0x06, 0xF8, 0x81, 0x4C, 0x0C, 0x71, 0x8E, 0xC4, 0x01, 0x64, 0x86, + 0x45, 0x46, 0x8D, 0x73, 0xDD, 0x25, 0xEA, 0x60, 0x69, 0xEF, 0x50, 0x60, 0xEB, 0x65, 0x56, 0x35, + 0x7C, 0xCD, 0x69, 0xB7, 0x59, 0x96, 0xB9, 0x44, 0x48, 0x48, 0x96, 0x4A, 0x13, 0x00, 0x05, 0xAB, + 0x4B, 0x45, 0x17, 0xCC, 0x63, 0xB0, 0xCE, 0xC0, 0x4C, 0x60, 0xD8, 0xD8, 0xA2, 0x4E, 0xB2, 0x84, + 0x2A, 0x10, 0x74, 0xD3, 0x03, 0xCE, 0xE3, 0xCC, 0x26, 0x88, 0x48, 0x66, 0x2A, 0xC6, 0x60, 0x52, + 0x65, 0x79, 0x86, 0x8A, 0x46, 0x69, 0x60, 0x40, 0xD1, 0xE0, 0x87, 0x04, 0x42, 0x48, 0x61, 0x00, + 0x79, 0xB9, 0x1A, 0x2C, 0x44, 0x48, 0x5F, 0x09, 0x0E, 0xB0, 0xCC, 0x18, 0x12, 0xA9, 0x2C, 0x21, + 0x04, 0x24, 0x03, 0x7E, 0x59, 0x53, 0x59, 0x2D, 0xEC, 0x6B, 0x4A, 0xDE, 0xA7, 0x0B, 0xD5, 0xA8, + 0x33, 0xF2, 0x13, 0x43, 0x30, 0xB1, 0x03, 0x80, 0x89, 0x1A, 0x13, 0x66, 0x5C, 0xF0, 0xFF, 0xFB, + 0x92, 0x64, 0xE3, 0x04, 0x04, 0x11, 0x2D, 0x48, 0x93, 0x9A, 0x2A, 0xF0, 0x30, 0xC0, 0xC9, 0xD8, + 0x08, 0x23, 0x21, 0x8E, 0xB8, 0xC5, 0x2D, 0x4C, 0xB0, 0x72, 0xC0, 0xF1, 0x0E, 0x26, 0xE8, 0x30, + 0x88, 0x60, 0x43, 0x73, 0xF6, 0x80, 0x12, 0x1A, 0x09, 0x88, 0x87, 0x1F, 0x9B, 0xE5, 0x53, 0x67, + 0xEF, 0xB6, 0x2B, 0x6D, 0x9F, 0xD4, 0x51, 0x15, 0x32, 0xA6, 0x60, 0xE3, 0x71, 0xAB, 0x71, 0x5B, + 0xE4, 0xD3, 0xDA, 0x9F, 0x2A, 0x96, 0x69, 0xEC, 0x31, 0x49, 0x51, 0x8E, 0x76, 0xE4, 0xFE, 0xEF, + 0xF6, 0x53, 0x74, 0x80, 0x00, 0x1F, 0x12, 0x20, 0x8B, 0xE7, 0x3A, 0x87, 0xEA, 0xC8, 0xDB, 0x29, + 0xFE, 0xCF, 0xE7, 0x28, 0xD2, 0xA2, 0x4F, 0xFB, 0x00, 0xAE, 0x26, 0x2E, 0xF5, 0x13, 0xDF, 0xDB, + 0x3D, 0x96, 0x5C, 0xC5, 0xF6, 0xFA, 0xB5, 0x2E, 0xC6, 0x25, 0x17, 0xFF, 0xD1, 0xDE, 0xA8, 0x8D, + 0xBD, 0x4B, 0xD2, 0x85, 0xBD, 0xCA, 0xE8, 0x55, 0x1E, 0x8F, 0xF2, 0x3F, 0x1E, 0xC0, 0x00, 0x00, + 0x32, 0xE4, 0xB5, 0x9D, 0x95, 0x17, 0x2A, 0xFA, 0x54, 0x05, 0xB5, 0x17, 0x1C, 0x11, 0x60, 0x15, + 0xFC, 0xDA, 0xA5, 0x0A, 0x0F, 0x47, 0xD2, 0x21, 0x20, 0xD1, 0x41, 0x76, 0x67, 0x33, 0x48, 0x54, + 0x01, 0x90, 0x20, 0x4C, 0x1C, 0x98, 0x89, 0x7F, 0x97, 0x82, 0x95, 0x19, 0x02, 0x2C, 0x29, 0x96, + 0xCA, 0x7F, 0x94, 0x07, 0x93, 0x32, 0xA5, 0x81, 0x46, 0xC6, 0xB2, 0xD4, 0x2B, 0x8B, 0xA5, 0x01, + 0x7E, 0x5D, 0x4E, 0x9D, 0x71, 0x8A, 0x81, 0x7A, 0x77, 0x15, 0xE1, 0xBC, 0x5C, 0x9A, 0x4C, 0x49, + 0xBD, 0xC1, 0x05, 0x08, 0x30, 0x00, 0xDB, 0xD2, 0x18, 0xEB, 0x2C, 0xB2, 0xBA, 0xCE, 0xD4, 0x82, + 0x75, 0x01, 0x67, 0xD9, 0xB4, 0x6A, 0x10, 0xAB, 0x96, 0xE7, 0xAD, 0xCD, 0xEB, 0x07, 0x15, 0x6E, + 0x39, 0xA0, 0x64, 0x45, 0x54, 0x9F, 0xFE, 0x9D, 0x7F, 0x56, 0x00, 0x00, 0xE0, 0x05, 0x1C, 0x94, + 0x18, 0x1C, 0x1F, 0x42, 0x41, 0x4B, 0x3B, 0x08, 0xF7, 0xAD, 0xFF, 0xC5, 0x78, 0x67, 0xFF, 0xFF, + 0xFB, 0xFC, 0xBF, 0xD9, 0x00, 0xCC, 0x68, 0xEE, 0xBD, 0x4B, 0xCB, 0xE8, 0xAB, 0x12, 0x0B, 0xB5, + 0x93, 0x5A, 0x9F, 0xB9, 0xC1, 0x37, 0xCF, 0xB8, 0x88, 0xE4, 0x20, 0x5E, 0xC2, 0xE7, 0x7D, 0x11, + 0xF7, 0xFB, 0x00, 0x69, 0x1C, 0xF2, 0xA1, 0xE4, 0xD1, 0x65, 0x03, 0x5F, 0x05, 0x0C, 0xAA, 0x44, + 0x52, 0x82, 0x5E, 0x21, 0xBD, 0x8D, 0xC2, 0xD7, 0x50, 0x28, 0xD0, 0xCA, 0x48, 0xF3, 0x21, 0x1C, + 0x87, 0x03, 0x81, 0xCD, 0x51, 0x52, 0xC1, 0x88, 0x46, 0x06, 0xA3, 0x30, 0x1F, 0xB4, 0x86, 0x3D, + 0xA1, 0x6E, 0x82, 0x81, 0xD7, 0xC0, 0xBD, 0x71, 0xD0, 0x84, 0x40, 0x51, 0x4C, 0x2E, 0x31, 0x91, + 0x3F, 0x23, 0x20, 0x62, 0x8A, 0xCA, 0xE9, 0x34, 0xD6, 0x49, 0x1E, 0x04, 0x82, 0x52, 0x2B, 0xB9, + 0x8F, 0x2F, 0x11, 0x20, 0xC8, 0xAB, 0x02, 0x3B, 0x6C, 0x21, 0xD7, 0x42, 0x91, 0xD2, 0xE5, 0x43, + 0xFF, 0xFB, 0x92, 0x64, 0xEF, 0x84, 0x04, 0x8D, 0x31, 0x47, 0x13, 0x78, 0x4C, 0xB0, 0x3A, 0x89, + 0xD9, 0xC8, 0x14, 0x02, 0xF1, 0xCF, 0x90, 0xBD, 0x27, 0x4D, 0x3C, 0x52, 0xC0, 0xE1, 0xA5, 0xA7, + 0xE8, 0x30, 0x8E, 0xBB, 0x83, 0xC2, 0x13, 0x89, 0xB8, 0x97, 0xE3, 0xF2, 0x81, 0x02, 0x1B, 0x06, + 0x64, 0xF3, 0xC2, 0xB0, 0xD1, 0x14, 0xCE, 0xEF, 0xC4, 0x8F, 0x27, 0x27, 0x27, 0x1C, 0xCE, 0x4B, + 0x16, 0xC0, 0xFA, 0xBB, 0xA1, 0x71, 0x89, 0x45, 0xC4, 0xBA, 0x58, 0xDE, 0x69, 0xAA, 0xA3, 0x4D, + 0xE6, 0xD5, 0xAE, 0x75, 0x96, 0x59, 0xE8, 0xDD, 0xFE, 0xFD, 0x38, 0x00, 0x04, 0x32, 0x1D, 0x97, + 0x70, 0xCE, 0x10, 0x09, 0x18, 0x18, 0x41, 0x0F, 0x4A, 0xD0, 0xC3, 0xC0, 0x21, 0x6B, 0x53, 0x40, + 0x61, 0x03, 0xDA, 0x43, 0xA1, 0x09, 0xED, 0xD6, 0x4C, 0x8A, 0x0A, 0xC3, 0x09, 0x39, 0x62, 0x14, + 0x93, 0x6A, 0x43, 0xD8, 0xE7, 0x0C, 0x00, 0xCF, 0xB2, 0x0C, 0x8A, 0x8B, 0xB8, 0x34, 0x71, 0xC8, + 0xE4, 0x09, 0x24, 0x4E, 0x35, 0x48, 0x03, 0xC2, 0xC8, 0x6A, 0xC6, 0x34, 0xE8, 0xB3, 0x34, 0x34, + 0x10, 0x63, 0x4D, 0x62, 0x5F, 0x24, 0xC1, 0x26, 0x26, 0xDE, 0x75, 0xBE, 0x25, 0x6A, 0xC6, 0x2C, + 0x68, 0x3C, 0x44, 0x60, 0x4C, 0x01, 0x43, 0xF3, 0x12, 0x2D, 0x39, 0x02, 0x23, 0x7A, 0x17, 0x80, + 0xC0, 0x84, 0x21, 0x70, 0x10, 0x73, 0x1B, 0x6E, 0x8A, 0x68, 0x07, 0x05, 0x1F, 0xCB, 0x1C, 0xD2, + 0x10, 0x34, 0x4A, 0x79, 0xA1, 0x94, 0x80, 0x80, 0xE0, 0x75, 0xF0, 0xD1, 0x5D, 0xFA, 0x06, 0x7E, + 0xA6, 0x6B, 0x1D, 0x9C, 0x32, 0x75, 0x35, 0x87, 0xE7, 0xAE, 0xDE, 0x77, 0xDD, 0xB6, 0xA0, 0x01, + 0x03, 0x52, 0x12, 0x18, 0x54, 0x38, 0x66, 0x50, 0x11, 0x51, 0xC2, 0x87, 0xAA, 0x25, 0x7B, 0xFF, + 0xA7, 0x66, 0xDC, 0x62, 0x94, 0x83, 0x0A, 0xE2, 0xAD, 0x1C, 0x66, 0xE1, 0x45, 0x2C, 0x95, 0x1B, + 0x04, 0xEE, 0x59, 0xED, 0xCA, 0xFA, 0x6E, 0x45, 0x24, 0x30, 0x02, 0x0C, 0x23, 0xFF, 0x18, 0x27, + 0x46, 0xDC, 0x3A, 0x04, 0xF4, 0xE5, 0x57, 0xFD, 0xCB, 0xFB, 0xAE, 0xBF, 0xFF, 0x4B, 0xA7, 0xA7, + 0xF4, 0xDD, 0x25, 0xB7, 0x6D, 0x48, 0xCE, 0x9F, 0x2B, 0x16, 0x88, 0xC3, 0x3C, 0xC1, 0xE2, 0xC5, + 0x61, 0xE2, 0xEB, 0x7D, 0xF4, 0xE9, 0x48, 0x0A, 0x46, 0xC5, 0x39, 0x0A, 0x00, 0x00, 0x09, 0x52, + 0x95, 0x8C, 0x18, 0x09, 0xD9, 0xCC, 0x9A, 0x99, 0x81, 0x18, 0xB0, 0x88, 0xCC, 0xD9, 0x86, 0xF8, + 0x9C, 0x39, 0xB9, 0x84, 0x9B, 0xA0, 0x90, 0xC5, 0x48, 0xCC, 0x34, 0x74, 0x44, 0x30, 0x10, 0x70, + 0x77, 0x61, 0xC6, 0x46, 0x1E, 0x66, 0x63, 0xE0, 0x42, 0x02, 0x21, 0x86, 0x3C, 0x8D, 0x45, 0xCB, + 0x68, 0x2E, 0xCC, 0x3A, 0x30, 0x1A, 0x56, 0x02, 0xA0, 0xED, 0xFA, 0x81, 0x30, 0x19, 0x7C, 0x34, + 0x1C, 0x07, 0x23, 0x82, 0x18, 0x12, 0x11, 0x47, 0x1C, 0x49, 0x32, 0xFE, 0x8E, 0x38, 0xB9, 0x61, + 0x19, 0x74, 0xFF, 0xFB, 0x92, 0x64, 0xEE, 0x0E, 0x04, 0xA3, 0x2F, 0xC6, 0x0B, 0x9A, 0x63, 0xD0, + 0x41, 0x61, 0x09, 0xAA, 0x0C, 0x63, 0x12, 0x0F, 0x7C, 0xC1, 0x20, 0x4D, 0xA0, 0x5A, 0x00, 0xCF, + 0x1E, 0x69, 0xB0, 0x50, 0x0A, 0x8E, 0x59, 0x01, 0x7C, 0xD8, 0x2A, 0xE0, 0x7E, 0x21, 0x90, 0x46, + 0x2B, 0xEA, 0xE8, 0x46, 0xC2, 0x26, 0x36, 0x09, 0xFF, 0xFA, 0x27, 0x86, 0x87, 0x0B, 0x3D, 0x3A, + 0xBF, 0x1C, 0x5A, 0xFF, 0xFD, 0x68, 0xEF, 0xD1, 0xC8, 0x6B, 0x4F, 0x75, 0x0E, 0xF1, 0xAC, 0x80, + 0x00, 0x02, 0x90, 0x02, 0xD7, 0x6E, 0x2D, 0xD0, 0x09, 0x8D, 0x50, 0x8D, 0x0A, 0x7B, 0x92, 0x2E, + 0x70, 0xB6, 0xD2, 0x59, 0xBD, 0x18, 0xE3, 0x42, 0xAC, 0x7B, 0x7F, 0xEC, 0x56, 0x9E, 0xD0, 0xA9, + 0xCE, 0x89, 0x75, 0x5C, 0x23, 0x0D, 0xAD, 0x67, 0x27, 0x77, 0x25, 0x81, 0xF7, 0x11, 0x55, 0xEA, + 0x5A, 0x1D, 0x3D, 0x8B, 0xBD, 0x08, 0x71, 0x95, 0x92, 0x2D, 0x68, 0xC2, 0x80, 0x18, 0x95, 0x19, + 0x61, 0xC0, 0x00, 0xB1, 0xAF, 0x87, 0x26, 0x05, 0x08, 0x98, 0x1C, 0x8C, 0x60, 0xE1, 0x09, 0x87, + 0xA8, 0x46, 0x06, 0x1A, 0x1B, 0xAC, 0x7E, 0x0D, 0x2A, 0x99, 0x10, 0x40, 0x5A, 0x83, 0x4A, 0xB4, + 0xD4, 0x77, 0x3F, 0xD9, 0x8C, 0x59, 0xD0, 0x87, 0xA1, 0x04, 0xC0, 0x87, 0x14, 0xA1, 0x5D, 0x28, + 0xE0, 0x8C, 0x1B, 0x01, 0x73, 0x2C, 0xA2, 0x63, 0x68, 0xA6, 0x2B, 0xB1, 0x01, 0x90, 0xDA, 0xD1, + 0x41, 0xDA, 0x66, 0x14, 0x0D, 0x02, 0x2C, 0x50, 0x44, 0x05, 0x90, 0x2D, 0x76, 0x29, 0x00, 0x3E, + 0x58, 0x5B, 0x67, 0x56, 0x53, 0xBD, 0x13, 0xD3, 0x55, 0xE4, 0x6E, 0x6E, 0xA0, 0x4C, 0x3A, 0x2E, + 0x71, 0x2B, 0x98, 0x14, 0x81, 0x0C, 0xCB, 0x42, 0x98, 0x82, 0xF9, 0xB7, 0xF5, 0xFC, 0x5D, 0x7D, + 0xA4, 0x50, 0xCA, 0x66, 0xDD, 0x99, 0xBB, 0xD7, 0xA7, 0xD5, 0xF4, 0x0B, 0x1A, 0xB0, 0x70, 0x69, + 0x68, 0x98, 0x14, 0x27, 0x8A, 0xFD, 0x70, 0x00, 0x00, 0x00, 0x00, 0x10, 0xDB, 0x6E, 0x11, 0x8C, + 0x19, 0x33, 0x74, 0xC2, 0x05, 0x03, 0xAA, 0x06, 0x48, 0xAF, 0x3E, 0x4E, 0x77, 0xBA, 0xE7, 0x8A, + 0x5E, 0xE4, 0xB1, 0x1F, 0xFF, 0x80, 0x24, 0x43, 0x3E, 0x91, 0x49, 0xDF, 0x7C, 0xED, 0x77, 0x19, + 0x2D, 0x1F, 0x3C, 0x34, 0xF6, 0xC0, 0x51, 0x75, 0x38, 0xAB, 0x91, 0x6A, 0x83, 0xBA, 0x88, 0x44, + 0x6A, 0x73, 0x3D, 0x85, 0x95, 0x80, 0x00, 0x00, 0x02, 0x9A, 0x92, 0x5C, 0x66, 0xDA, 0x34, 0x08, + 0xD3, 0x1A, 0x82, 0xE7, 0x30, 0xB0, 0x33, 0x01, 0x60, 0x21, 0xE3, 0x22, 0x59, 0x0C, 0x6D, 0x03, + 0x09, 0x02, 0xCE, 0xDC, 0x66, 0x4C, 0xA1, 0x17, 0xA6, 0xC5, 0x40, 0x8A, 0x06, 0x57, 0x3D, 0x4D, + 0x7A, 0xD8, 0x1A, 0x55, 0x0A, 0xA6, 0x6D, 0x47, 0x3A, 0x1E, 0x95, 0x23, 0xA0, 0x30, 0x4F, 0xAB, + 0x62, 0xF8, 0xD3, 0xA5, 0xC2, 0x78, 0xDC, 0x16, 0x09, 0x0C, 0x51, 0xE2, 0x47, 0xA0, 0x50, 0xB1, + 0xE0, 0xA1, 0xDA, 0x2C, 0xFF, 0xFB, 0x92, 0x64, 0xEA, 0x0C, 0x03, 0xF3, 0x2E, 0x48, 0x1B, 0x66, + 0x16, 0x80, 0x3E, 0x01, 0x99, 0xCD, 0x20, 0x49, 0x10, 0x11, 0x40, 0xBB, 0x1E, 0x4E, 0x69, 0x0B, + 0xC0, 0xFA, 0x17, 0xE6, 0xF4, 0x30, 0x8A, 0xA0, 0xC9, 0xBE, 0x1E, 0xE9, 0x33, 0x72, 0x9B, 0x10, + 0x6B, 0x5B, 0x78, 0xB8, 0xDC, 0x72, 0x37, 0x36, 0x69, 0xCE, 0xFB, 0xBF, 0x1D, 0x20, 0x00, 0x08, + 0x0C, 0x34, 0x56, 0xB6, 0xA9, 0x85, 0x1E, 0xB7, 0x22, 0xAB, 0x3E, 0xBD, 0x13, 0x5C, 0xE4, 0x6D, + 0x7D, 0xEA, 0xDE, 0xDF, 0x8C, 0x4C, 0x4A, 0x26, 0xB5, 0x3F, 0xFB, 0x8E, 0xB0, 0x6C, 0xD1, 0xEB, + 0x9C, 0x19, 0x05, 0x05, 0x06, 0x01, 0x4D, 0x30, 0x32, 0x3C, 0x91, 0x6A, 0x48, 0x05, 0xC3, 0x0D, + 0x2F, 0x08, 0x9D, 0x1E, 0x06, 0x04, 0x89, 0x80, 0x32, 0xE5, 0xEA, 0x28, 0xDC, 0x6F, 0x89, 0x60, + 0xA5, 0x53, 0x52, 0x15, 0x32, 0x11, 0xF3, 0x6E, 0xC9, 0x38, 0x2D, 0xB3, 0x78, 0x27, 0x0B, 0x95, + 0x9B, 0x4B, 0x09, 0xB3, 0xD5, 0x19, 0xA3, 0xE9, 0xE4, 0xB8, 0x1B, 0x31, 0x21, 0x9E, 0xA4, 0x99, + 0x81, 0x40, 0x80, 0x48, 0xCB, 0x09, 0x44, 0x82, 0x93, 0xDC, 0xC7, 0x14, 0x16, 0x4A, 0xBA, 0x6A, + 0xE5, 0xC1, 0x2A, 0x21, 0x14, 0x97, 0x19, 0xA1, 0x84, 0x54, 0x11, 0x30, 0x20, 0x42, 0x27, 0xC2, + 0x20, 0x2F, 0xE0, 0xCA, 0xA0, 0x20, 0x19, 0x8B, 0x40, 0x1D, 0x29, 0x5B, 0xD6, 0x7B, 0x1F, 0x64, + 0x4E, 0xDA, 0x95, 0x50, 0x02, 0x78, 0x0A, 0x10, 0xCE, 0x53, 0x49, 0x6D, 0x34, 0xF2, 0x52, 0x5C, + 0xE5, 0xCC, 0x94, 0x06, 0x50, 0x8A, 0xC6, 0x00, 0xBA, 0x88, 0x14, 0x23, 0x8A, 0x43, 0xF2, 0xE8, + 0x0C, 0x66, 0x28, 0x83, 0x7B, 0x6E, 0x0F, 0x03, 0x1C, 0xC1, 0x70, 0xF0, 0x60, 0xA3, 0x62, 0x03, + 0x0B, 0x28, 0x36, 0x04, 0x79, 0xF5, 0x92, 0xC2, 0x65, 0x5D, 0x8C, 0x54, 0xB1, 0x04, 0x31, 0x0E, + 0xF6, 0x39, 0x0F, 0x48, 0x6C, 0x89, 0xD2, 0xC7, 0x5E, 0x9C, 0x00, 0x08, 0x41, 0x71, 0xC9, 0x70, + 0xE5, 0x91, 0x9C, 0x10, 0xC3, 0xC3, 0x13, 0x40, 0xF6, 0x34, 0xEA, 0x2D, 0x26, 0x48, 0x84, 0xB4, + 0x8D, 0x6F, 0xD8, 0x5A, 0x8A, 0x3C, 0x18, 0xD4, 0x1C, 0x6F, 0x69, 0x4F, 0xA3, 0x6A, 0x6E, 0xD9, + 0x15, 0xAF, 0x97, 0x4A, 0x05, 0x0C, 0x25, 0xEA, 0xD0, 0x68, 0x3F, 0x50, 0x16, 0xC4, 0x4A, 0x14, + 0x1A, 0x06, 0x7A, 0x5D, 0x53, 0x50, 0x46, 0x15, 0x78, 0x3F, 0x63, 0xA8, 0x6A, 0x03, 0x49, 0x59, + 0xD9, 0x66, 0xD0, 0x86, 0x08, 0xC2, 0x0A, 0x80, 0x00, 0x00, 0x00, 0x93, 0x73, 0x69, 0x53, 0xEE, + 0xBB, 0x8A, 0x82, 0x0B, 0x08, 0x8A, 0xE8, 0x6E, 0x36, 0x61, 0x29, 0x20, 0x69, 0xDC, 0x14, 0x29, + 0x1C, 0x84, 0x00, 0x58, 0x3A, 0x53, 0xF5, 0xE4, 0x26, 0xAA, 0xA9, 0x17, 0xE5, 0x05, 0x2D, 0x1A, + 0x30, 0x59, 0x24, 0x59, 0xBB, 0x32, 0x57, 0x54, 0x58, 0x56, 0x43, 0x45, 0x13, 0x58, 0x2A, 0xD4, + 0x8C, 0x58, 0xBE, 0x03, 0x03, 0xBF, 0xFF, 0xFB, 0x92, 0x64, 0xE6, 0x84, 0x03, 0x1F, 0x25, 0xCD, + 0xD3, 0x09, 0x1C, 0x44, 0x3A, 0x44, 0x59, 0xF9, 0x08, 0x02, 0xC1, 0x94, 0x4C, 0xBF, 0x14, 0x2D, + 0xE5, 0x32, 0xC1, 0x33, 0x90, 0xA6, 0x28, 0x64, 0x8C, 0xB0, 0x02, 0x77, 0xF0, 0x6C, 0xA2, 0x75, + 0x3C, 0x65, 0x8C, 0xF8, 0x54, 0x3D, 0xEE, 0x25, 0xE9, 0x2A, 0xB1, 0xF9, 0x8D, 0xF3, 0x84, 0x5C, + 0x72, 0x5D, 0x50, 0x2C, 0xC5, 0xB6, 0xB7, 0xFE, 0xFF, 0xF2, 0xFA, 0x2A, 0x48, 0x52, 0x38, 0xFA, + 0xDF, 0x5B, 0x58, 0xAD, 0x3F, 0xFF, 0xD3, 0x73, 0x21, 0x11, 0x03, 0x0C, 0x08, 0xDB, 0x83, 0xE1, + 0x26, 0x10, 0xF6, 0x9F, 0xA6, 0xC1, 0x98, 0x26, 0x81, 0xB1, 0xBF, 0x3C, 0x92, 0x3F, 0xFD, 0x0C, + 0x86, 0x9C, 0x4C, 0x58, 0x97, 0x76, 0x9B, 0x9E, 0xF5, 0xB4, 0x3A, 0x27, 0xA1, 0x14, 0x76, 0x27, + 0x63, 0xEF, 0x32, 0x22, 0x49, 0x85, 0x4E, 0xB5, 0xA6, 0xA0, 0x1B, 0x40, 0x00, 0x82, 0x9C, 0xC1, + 0xF5, 0x03, 0x0D, 0x0D, 0xEC, 0x6F, 0x85, 0x19, 0x71, 0xA6, 0x90, 0x98, 0x0C, 0xD8, 0xDA, 0x93, + 0x66, 0x34, 0x1C, 0x18, 0xFB, 0xBB, 0x35, 0x2B, 0x8C, 0x79, 0x73, 0x52, 0x00, 0xFD, 0x4F, 0x32, + 0x26, 0x47, 0x1C, 0x92, 0x05, 0x1E, 0x9C, 0xD0, 0x97, 0xD1, 0x8C, 0x62, 0xDE, 0x7F, 0xE3, 0x0B, + 0xA1, 0x67, 0xBE, 0xDB, 0x58, 0x36, 0x50, 0xBB, 0xE7, 0x80, 0x42, 0x80, 0x67, 0x6C, 0x91, 0x59, + 0xDC, 0x85, 0xC3, 0x6C, 0x42, 0x2D, 0x5F, 0x16, 0x48, 0xEA, 0xF1, 0xA6, 0x17, 0xF6, 0x99, 0xEE, + 0x67, 0x0E, 0xFF, 0x9C, 0xA7, 0x15, 0x0C, 0x15, 0x72, 0x0F, 0x51, 0x40, 0x18, 0x55, 0x79, 0x5A, + 0xD6, 0xCB, 0x61, 0x01, 0x13, 0x64, 0x57, 0x8C, 0xBA, 0x85, 0x22, 0xCD, 0x9A, 0x2D, 0xF1, 0x63, + 0x78, 0xD7, 0x84, 0x05, 0xD5, 0x2E, 0x45, 0x2C, 0xB6, 0xCF, 0xA9, 0x96, 0x64, 0x62, 0x24, 0x80, + 0x09, 0x4D, 0xFF, 0x59, 0x11, 0xC1, 0x19, 0xA3, 0xAF, 0xF9, 0x1E, 0x0E, 0x5C, 0xF8, 0xF8, 0x8E, + 0xC0, 0xE7, 0x1E, 0xF6, 0xC0, 0x63, 0x02, 0xD7, 0x7F, 0xCB, 0x06, 0x31, 0xB7, 0xA1, 0xE2, 0x01, + 0xCF, 0x51, 0x9B, 0x03, 0xEF, 0x2E, 0x3E, 0x2B, 0x22, 0x20, 0x7A, 0xCB, 0x56, 0xD6, 0x1D, 0xC3, + 0xFD, 0x82, 0xD3, 0x01, 0x47, 0x9A, 0x08, 0x0C, 0x15, 0x69, 0xD5, 0xA2, 0x00, 0x9D, 0x91, 0x40, + 0x00, 0x84, 0x66, 0x60, 0x96, 0x89, 0xA9, 0x82, 0xA9, 0x32, 0x66, 0x25, 0xD1, 0xA9, 0xC8, 0x26, + 0x6E, 0x3F, 0x19, 0x8D, 0xA4, 0x61, 0x81, 0x21, 0xB3, 0x0A, 0x86, 0x90, 0x26, 0x18, 0x90, 0x50, + 0x71, 0x82, 0x48, 0x2B, 0xBA, 0x68, 0x32, 0x00, 0x08, 0x16, 0x66, 0x37, 0x9D, 0x04, 0x0D, 0xC4, + 0x68, 0xF1, 0x82, 0x8E, 0x75, 0x16, 0x16, 0xBD, 0x93, 0x81, 0x44, 0xB1, 0x84, 0xE9, 0x95, 0x88, + 0x94, 0x94, 0x02, 0x04, 0x08, 0x8C, 0x0B, 0x21, 0x0A, 0x82, 0x59, 0xCA, 0x58, 0x5C, 0xF6, 0x65, + 0x0A, 0x44, 0xE4, 0xF2, 0x68, 0x2D, 0x4D, 0xB9, 0xFF, 0xFB, 0x92, 0x64, 0xDE, 0x84, 0x03, 0x5F, + 0x30, 0xCB, 0x53, 0x2F, 0x1C, 0x40, 0x34, 0x61, 0x6A, 0x9D, 0x3C, 0x23, 0x1B, 0x90, 0x40, 0xC5, + 0x20, 0x6D, 0x60, 0xB1, 0x00, 0xFA, 0x11, 0xA9, 0x30, 0x30, 0x89, 0x7E, 0xA2, 0x4A, 0x69, 0x2D, + 0x00, 0x08, 0x14, 0x8C, 0x7E, 0xD5, 0xF2, 0x63, 0xB2, 0x27, 0xF7, 0x0A, 0x8F, 0x80, 0x18, 0x3E, + 0x96, 0x9E, 0x33, 0x3E, 0xBB, 0x4A, 0xD8, 0x61, 0xFF, 0x10, 0xC9, 0xDA, 0xD8, 0xAF, 0x40, 0xC5, + 0x7A, 0xA1, 0xFE, 0x9D, 0x45, 0x48, 0x19, 0xB1, 0x91, 0xF1, 0x7A, 0x37, 0x5B, 0x89, 0xAD, 0x58, + 0xBD, 0x2C, 0x0D, 0x3D, 0x4A, 0x9A, 0x1A, 0x03, 0x40, 0x97, 0x82, 0x00, 0x20, 0x40, 0x8E, 0x4A, + 0x2E, 0x50, 0x74, 0x49, 0x8C, 0xAF, 0x99, 0x89, 0xDF, 0xA6, 0x95, 0x39, 0x69, 0xA5, 0x1F, 0xAE, + 0x59, 0x0B, 0xA1, 0x5C, 0x8A, 0x1A, 0xAE, 0xBD, 0x93, 0xFD, 0xEC, 0xEE, 0xC4, 0xD2, 0x69, 0x95, + 0xAD, 0x9B, 0x6B, 0x53, 0xFE, 0x8F, 0xF7, 0x9A, 0xE6, 0x66, 0x43, 0xBB, 0x2A, 0x99, 0x82, 0x8D, + 0x82, 0x3F, 0x47, 0x48, 0xB0, 0x08, 0x2B, 0x94, 0xB4, 0xA5, 0xCA, 0x6C, 0xC9, 0x66, 0x34, 0x0E, + 0x22, 0x04, 0x32, 0xA2, 0x03, 0x1B, 0x43, 0x34, 0xB4, 0x13, 0x2C, 0x8B, 0x31, 0x43, 0x23, 0x6D, + 0x10, 0x33, 0xA0, 0x4B, 0x15, 0x04, 0x93, 0x1F, 0xF4, 0x96, 0xD1, 0xDD, 0x3D, 0x0D, 0x40, 0x77, + 0xB1, 0xFA, 0x45, 0x53, 0x04, 0x4D, 0xE9, 0x77, 0xAC, 0xA5, 0x9C, 0x35, 0x25, 0x4C, 0x36, 0x4B, + 0x00, 0xC6, 0xD8, 0x73, 0x68, 0xEC, 0xA5, 0x5C, 0xE3, 0xE9, 0x04, 0x51, 0xB9, 0x7C, 0x7B, 0xAC, + 0xBB, 0xB9, 0xC8, 0x25, 0xA5, 0xBF, 0x85, 0x53, 0xCA, 0xA7, 0x48, 0xBA, 0xAA, 0x04, 0x11, 0x10, + 0x08, 0x85, 0xC0, 0x4D, 0x4F, 0x2D, 0x84, 0x09, 0x4C, 0xD6, 0xFE, 0x33, 0x9F, 0x1C, 0x42, 0x1C, + 0xEF, 0xFD, 0xAC, 0xFF, 0xD7, 0xBF, 0xC9, 0xD9, 0x67, 0xFF, 0xD0, 0x70, 0x01, 0x1D, 0xE7, 0x56, + 0x6A, 0x1D, 0xBF, 0xAA, 0xF0, 0x23, 0xF8, 0xE8, 0x66, 0xAE, 0xA4, 0xF3, 0xAB, 0x44, 0x8F, 0x5A, + 0x9F, 0xF8, 0xF1, 0x61, 0x41, 0xC5, 0xA2, 0x27, 0x23, 0xF3, 0x55, 0x14, 0x65, 0xCF, 0xB9, 0x24, + 0xC5, 0x19, 0x2E, 0xBE, 0xC6, 0xD4, 0x28, 0x0C, 0x3B, 0x14, 0x2C, 0xC4, 0x56, 0x2B, 0x01, 0xA1, + 0xE9, 0xC2, 0x10, 0x41, 0x88, 0xEB, 0xE6, 0x3B, 0x09, 0x98, 0x28, 0x54, 0x69, 0x12, 0x91, 0x99, + 0xCF, 0x66, 0x8B, 0x0B, 0x9B, 0x75, 0x0C, 0x20, 0x20, 0x99, 0xA1, 0x1A, 0x28, 0x26, 0x31, 0x30, + 0x78, 0xCF, 0xA6, 0xE3, 0x6D, 0x38, 0xC5, 0x8B, 0x41, 0x81, 0xF0, 0x4E, 0xC1, 0x9F, 0x83, 0x8B, + 0x32, 0x46, 0x49, 0x03, 0xB8, 0xC5, 0xA2, 0x85, 0x0B, 0x30, 0x69, 0x64, 0x89, 0x51, 0xD1, 0x11, + 0x65, 0xBD, 0x63, 0xA8, 0xCC, 0x8A, 0x6A, 0x0C, 0x9E, 0x8B, 0x0A, 0xF3, 0x28, 0x42, 0xF2, 0x66, + 0xEC, 0x01, 0xFE, 0x9E, 0xA0, 0x5C, 0x52, 0xAD, 0xB3, 0x94, 0xFF, 0xFB, 0x92, 0x64, 0xED, 0x0C, + 0x04, 0xCE, 0x31, 0x46, 0x0B, 0x9A, 0x5B, 0xD0, 0x3A, 0xC9, 0xE9, 0xFA, 0x14, 0x02, 0xC2, 0xCE, + 0xCC, 0xBD, 0x22, 0x4D, 0xE8, 0x6B, 0xC0, 0xCC, 0x0B, 0xE9, 0x24, 0x20, 0x8C, 0xFE, 0x66, 0x50, + 0x0B, 0x19, 0xB8, 0x8A, 0xFF, 0xE0, 0x48, 0x08, 0x39, 0x00, 0xE9, 0x82, 0x3E, 0x17, 0xEC, 0xCE, + 0xFE, 0x15, 0xB5, 0xE2, 0x73, 0xF6, 0x1E, 0xBD, 0xA7, 0x2B, 0x67, 0x0F, 0x47, 0x43, 0xC9, 0xF5, + 0x72, 0xBA, 0x16, 0xE2, 0x5C, 0xCA, 0xED, 0x90, 0x8E, 0x0E, 0x45, 0xAD, 0xF4, 0x6E, 0xB8, 0x4B, + 0xB7, 0xE3, 0x8F, 0x18, 0xB6, 0x70, 0x80, 0x08, 0x06, 0x38, 0x1B, 0x01, 0x19, 0x32, 0x93, 0x73, + 0x0E, 0x62, 0xA2, 0x5E, 0x0D, 0x5B, 0x84, 0x46, 0xEA, 0xEA, 0x72, 0xAB, 0x13, 0xE0, 0xC9, 0x81, + 0xED, 0x1B, 0x88, 0x16, 0x09, 0x34, 0xB4, 0x98, 0xBA, 0x0C, 0xBA, 0x79, 0x0D, 0x20, 0x25, 0x3C, + 0x95, 0xDD, 0xC3, 0x83, 0xDE, 0x49, 0xA6, 0xD6, 0xB4, 0x6B, 0x6D, 0x03, 0x40, 0x13, 0x6A, 0x1A, + 0xE3, 0x33, 0x32, 0xC7, 0x21, 0x69, 0x30, 0xE1, 0x80, 0x2A, 0x49, 0x8D, 0x6F, 0x1B, 0x5A, 0x11, + 0x9F, 0x32, 0x98, 0x08, 0x41, 0x90, 0x9F, 0x15, 0x00, 0x4C, 0x38, 0xA0, 0xCD, 0x5D, 0x4E, 0xEF, + 0xE9, 0x0B, 0x0C, 0x24, 0xCC, 0xE1, 0x20, 0x1F, 0xBA, 0xE2, 0x60, 0x0F, 0x38, 0x80, 0xBA, 0xEF, + 0x89, 0x2A, 0x0B, 0xEE, 0xF5, 0x57, 0xF4, 0xAC, 0x07, 0x1E, 0x05, 0x4C, 0xD8, 0x2A, 0xEB, 0xFE, + 0xCA, 0x64, 0x52, 0x4A, 0xCA, 0x5F, 0x9F, 0xEA, 0x11, 0x95, 0x02, 0x8D, 0x22, 0x9A, 0x06, 0x47, + 0xDC, 0x99, 0x0E, 0x6D, 0x21, 0x89, 0x04, 0x74, 0x16, 0x40, 0xEF, 0xA5, 0xA4, 0xCB, 0xF9, 0x88, + 0x35, 0x7F, 0x7D, 0xBF, 0xFC, 0x8A, 0x69, 0x15, 0x40, 0x90, 0x34, 0x92, 0x27, 0xED, 0x2C, 0x1E, + 0x0B, 0xB1, 0x1A, 0x6E, 0x28, 0x61, 0x56, 0xEC, 0x14, 0x52, 0x48, 0x0A, 0xAE, 0x87, 0xE9, 0x4B, + 0xC0, 0xDF, 0x55, 0x74, 0x12, 0x41, 0x02, 0x83, 0xFF, 0x10, 0xC4, 0x17, 0x01, 0x70, 0x59, 0xAD, + 0x55, 0xEE, 0xD4, 0xB5, 0xBF, 0xF6, 0x7B, 0xB5, 0xAD, 0xDA, 0xCC, 0xC6, 0xDD, 0x65, 0x65, 0x53, + 0xED, 0xF3, 0x59, 0x28, 0xE9, 0xB8, 0x43, 0xAA, 0x04, 0xE5, 0x16, 0x39, 0xAC, 0x5A, 0x92, 0x58, + 0x34, 0xF2, 0xE2, 0xB6, 0x34, 0x08, 0xA5, 0xFB, 0x96, 0xB4, 0xD2, 0x7D, 0x0A, 0x00, 0x04, 0x9A, + 0x47, 0x8C, 0xB0, 0x20, 0x09, 0x1A, 0x06, 0x84, 0x18, 0xE0, 0xF8, 0x02, 0x04, 0xC1, 0xD0, 0x0C, + 0xA1, 0xA0, 0x44, 0xB0, 0x67, 0xE4, 0x86, 0x9A, 0x0A, 0x24, 0xF2, 0x66, 0xC3, 0x46, 0x9F, 0x60, + 0x7B, 0xD4, 0x20, 0xE7, 0x53, 0x97, 0x35, 0x1F, 0x70, 0x92, 0x60, 0x30, 0x69, 0x40, 0x08, 0x44, + 0x0D, 0xD3, 0x2A, 0x6C, 0xC5, 0xD6, 0x2F, 0x72, 0x28, 0xD8, 0x8F, 0x3E, 0xD0, 0x7B, 0x8E, 0x81, + 0xED, 0xA4, 0xBD, 0x96, 0x2E, 0x3B, 0x94, 0xF2, 0xD7, 0xDA, 0x7F, 0x2C, 0xFF, 0xFB, 0x90, 0x64, + 0xED, 0x0C, 0x04, 0x60, 0x30, 0xC6, 0x8B, 0x99, 0x33, 0xD0, 0x3E, 0x42, 0x99, 0xC3, 0x14, 0x26, + 0x4A, 0x10, 0xCC, 0xB7, 0x1E, 0x4D, 0xE4, 0xCF, 0x40, 0xE7, 0x19, 0x69, 0xB0, 0xA0, 0x0B, 0x0E, + 0xE1, 0xF9, 0x0D, 0xA6, 0xCE, 0x10, 0xB4, 0x52, 0x0E, 0x60, 0x74, 0xBB, 0xBF, 0x23, 0x8B, 0xE3, + 0x2C, 0x96, 0xCC, 0x61, 0xDA, 0xDF, 0xA8, 0xC0, 0xC9, 0xBB, 0x1D, 0xB2, 0xBF, 0xA1, 0x5C, 0x58, + 0xED, 0xB0, 0x61, 0xEA, 0x77, 0x63, 0x85, 0x28, 0xE8, 0xFE, 0x8E, 0xD1, 0x51, 0x74, 0x96, 0x3A, + 0xE8, 0xE2, 0x21, 0xBF, 0x4B, 0x8C, 0x00, 0x00, 0x08, 0x1A, 0x96, 0x0A, 0x1D, 0xAE, 0x11, 0x8E, + 0x46, 0xBB, 0x25, 0x76, 0x2E, 0x15, 0x6A, 0x1B, 0xF4, 0x53, 0xB8, 0x88, 0xE4, 0xCD, 0x17, 0x4A, + 0x92, 0x46, 0x85, 0x1A, 0x0C, 0x34, 0xAD, 0x29, 0xA6, 0x9C, 0x85, 0xCA, 0xAA, 0x03, 0x45, 0xEC, + 0x41, 0xF7, 0x65, 0xC7, 0xA8, 0x40, 0x0F, 0x02, 0xBB, 0x0D, 0x0B, 0x30, 0xAC, 0x00, 0x00, 0x93, + 0x72, 0x55, 0xA5, 0x86, 0x0C, 0x8D, 0x41, 0xA6, 0x89, 0x3A, 0x0A, 0x2A, 0x60, 0xB1, 0x98, 0x94, + 0x07, 0xA5, 0x08, 0xA8, 0xE0, 0xE6, 0x83, 0xC2, 0x06, 0x41, 0x1A, 0x7A, 0x27, 0x5C, 0x2B, 0x37, + 0x0E, 0x30, 0xED, 0x97, 0x16, 0x24, 0xD5, 0xC1, 0x04, 0xD7, 0xBC, 0x73, 0x18, 0xEB, 0xA5, 0x0B, + 0xC2, 0x06, 0x2D, 0x69, 0x53, 0xA4, 0xE9, 0x7C, 0xDC, 0x46, 0x0D, 0x66, 0x84, 0xEA, 0xC1, 0x61, + 0x9E, 0x21, 0x6F, 0x31, 0x94, 0xD2, 0x0B, 0x81, 0xC4, 0x6B, 0xB9, 0xD3, 0x31, 0x55, 0x3E, 0x3D, + 0x44, 0xB5, 0xB5, 0xD4, 0x3A, 0xD6, 0x3D, 0xB4, 0xF5, 0x83, 0x32, 0x87, 0x82, 0x45, 0xC9, 0x21, + 0x2E, 0xA9, 0x29, 0x70, 0xD4, 0xB5, 0x2E, 0xCF, 0xB0, 0xE0, 0xF4, 0xFA, 0x47, 0x30, 0xF3, 0x84, + 0xF6, 0xEA, 0x44, 0x51, 0xBA, 0xBD, 0x38, 0x00, 0x00, 0x80, 0x66, 0x96, 0xF1, 0x14, 0x18, 0x0B, + 0x41, 0x34, 0x88, 0xC7, 0x0F, 0x0A, 0x00, 0x83, 0x25, 0x00, 0x3B, 0x3F, 0xA8, 0x37, 0x44, 0xA0, + 0x89, 0xB3, 0xE3, 0x45, 0x14, 0x55, 0x25, 0xC8, 0xC5, 0x62, 0xF7, 0x39, 0x0A, 0x34, 0x48, 0x78, + 0xD8, 0xA9, 0x09, 0x17, 0x31, 0xF6, 0x8D, 0xA8, 0x31, 0x64, 0x6D, 0xE7, 0x45, 0x0B, 0xCA, 0x50, + 0xD5, 0x0C, 0x45, 0x00, 0x09, 0xBF, 0xA8, 0x3A, 0x12, 0x62, 0x96, 0xA3, 0x4B, 0xA9, 0xCE, 0x06, + 0x71, 0x39, 0xEA, 0x30, 0xD0, 0xF0, 0xEE, 0xC3, 0x05, 0x33, 0x35, 0x94, 0x93, 0x10, 0x41, 0x31, + 0xE6, 0xB0, 0x62, 0xD1, 0xAD, 0xA0, 0x18, 0xB3, 0x6C, 0xB2, 0x75, 0xC0, 0xCB, 0x52, 0x25, 0xFA, + 0x4E, 0x8B, 0x01, 0x9E, 0xE9, 0xD1, 0x8A, 0x04, 0x6F, 0x10, 0x9A, 0xBB, 0xA0, 0x66, 0xEA, 0xDD, + 0xDA, 0x54, 0x38, 0x55, 0x10, 0x98, 0x26, 0xE2, 0xA3, 0x92, 0xD7, 0xF2, 0x8E, 0xCA, 0xB0, 0xB0, + 0x26, 0x93, 0x0D, 0xAB, 0x73, 0x04, 0x89, 0xC2, 0x25, 0x34, 0x86, 0x2C, 0x40, 0xFF, 0xFB, 0x92, + 0x64, 0xE6, 0x04, 0x04, 0x1D, 0x31, 0xC7, 0x13, 0x79, 0x13, 0xE0, 0x38, 0x00, 0x6A, 0x0C, 0x05, + 0x89, 0x01, 0x8F, 0x38, 0xB9, 0x24, 0xED, 0x3C, 0xB2, 0xC0, 0xF1, 0x01, 0x66, 0xA8, 0x11, 0x84, + 0x00, 0x8D, 0x73, 0xB9, 0x19, 0xE9, 0x65, 0xA2, 0x37, 0xBC, 0x3B, 0x90, 0x08, 0x10, 0x07, 0x80, + 0x69, 0x16, 0xA8, 0x92, 0xB4, 0x7E, 0xBA, 0xE7, 0x48, 0x6B, 0x7A, 0xD8, 0xEA, 0x12, 0xD6, 0x10, + 0x43, 0x86, 0xFC, 0xA6, 0xBA, 0x79, 0x8D, 0x6E, 0x75, 0x00, 0x08, 0x29, 0x29, 0xF4, 0xC7, 0xDA, + 0x78, 0x19, 0xF1, 0xE1, 0x9B, 0x44, 0x08, 0xCA, 0xEE, 0x1D, 0x3A, 0xF5, 0xF2, 0xFE, 0xDF, 0xFE, + 0x8B, 0x95, 0x1B, 0xB2, 0xEF, 0x63, 0x07, 0x72, 0x89, 0x47, 0x17, 0xDB, 0xD2, 0xFB, 0x78, 0x47, + 0x04, 0xC2, 0x62, 0x60, 0xBA, 0x4C, 0x14, 0x0E, 0xDB, 0xED, 0xFA, 0xE5, 0x37, 0xB8, 0xA0, 0x94, + 0x42, 0xE3, 0x56, 0x26, 0x84, 0x00, 0x00, 0x02, 0x00, 0x56, 0x7F, 0xF6, 0xA6, 0xA0, 0x92, 0xC9, + 0xB7, 0xCC, 0xD8, 0x94, 0xC0, 0x0C, 0x8B, 0x38, 0x30, 0x76, 0x92, 0xBE, 0x1C, 0xF4, 0x6F, 0x87, + 0xD1, 0xFD, 0xB1, 0xD8, 0x00, 0x4C, 0x40, 0x52, 0x5C, 0x09, 0xBC, 0x38, 0x48, 0xB9, 0x94, 0x7B, + 0x34, 0x8A, 0xCF, 0x88, 0xCD, 0x1A, 0xFD, 0xAF, 0xE9, 0x54, 0x34, 0x75, 0x49, 0x43, 0xC9, 0x03, + 0x94, 0x4D, 0x4B, 0x42, 0xB7, 0xC8, 0xBA, 0x36, 0xAF, 0x7F, 0xB1, 0x20, 0x80, 0x80, 0x57, 0x1D, + 0xB5, 0x8B, 0x67, 0xB5, 0xCB, 0x6B, 0x5F, 0x17, 0xAE, 0x9A, 0x38, 0xB2, 0xE8, 0x57, 0xF3, 0x7F, + 0xDF, 0x4A, 0x68, 0x92, 0x93, 0x49, 0x49, 0x1B, 0x62, 0x9F, 0xBE, 0xD1, 0x07, 0x40, 0x13, 0x2E, + 0xEB, 0xA9, 0x09, 0x80, 0x5E, 0xA5, 0x0C, 0xB5, 0xBF, 0x93, 0xF4, 0xB4, 0x59, 0x40, 0xB5, 0xB3, + 0x03, 0xDC, 0x14, 0xDB, 0xBB, 0xB2, 0x25, 0x36, 0xA0, 0x40, 0x73, 0x15, 0x91, 0x54, 0xB5, 0x6E, + 0x32, 0x87, 0x5E, 0x86, 0xA5, 0x26, 0xA3, 0x13, 0x86, 0x1E, 0x79, 0x0A, 0x20, 0xE7, 0xD2, 0x71, + 0x84, 0xE5, 0x43, 0x89, 0x2A, 0x85, 0x00, 0x65, 0x2E, 0x58, 0x04, 0x22, 0x66, 0xE5, 0x29, 0x9A, + 0x42, 0xA6, 0x07, 0x0D, 0x19, 0x38, 0x54, 0x70, 0xB0, 0xE9, 0xB6, 0x00, 0x67, 0x1C, 0x3B, 0x01, + 0x92, 0xE6, 0x75, 0x2B, 0x98, 0xA8, 0x38, 0x00, 0x54, 0x9A, 0x39, 0xEE, 0x61, 0x94, 0x51, 0x08, + 0xFC, 0xC5, 0xA3, 0xB2, 0x23, 0x46, 0xE0, 0x1E, 0x48, 0x42, 0x58, 0xAB, 0x63, 0xF6, 0x32, 0xD2, + 0xCD, 0x03, 0x42, 0x53, 0x35, 0xA2, 0xB4, 0xD0, 0x7D, 0x3E, 0xD0, 0x9C, 0x86, 0x46, 0x39, 0x8A, + 0x58, 0xFF, 0x83, 0x1B, 0x59, 0xA3, 0x81, 0x46, 0x98, 0x9B, 0x73, 0x8B, 0xC9, 0xDF, 0x66, 0x5E, + 0xC5, 0x19, 0xA9, 0x71, 0x52, 0x06, 0x57, 0x2D, 0x9A, 0x7D, 0x58, 0x37, 0x05, 0x48, 0x98, 0x20, + 0x51, 0x0A, 0x10, 0x24, 0xD4, 0xE3, 0xA8, 0x45, 0x05, 0x6D, 0x2B, 0x6D, 0xC9, 0xE4, 0xD0, 0xFF, + 0xFB, 0x92, 0x64, 0xEC, 0x00, 0x04, 0x08, 0x21, 0xC7, 0x93, 0x79, 0x33, 0x60, 0x3B, 0xC6, 0x4A, + 0x2C, 0x3C, 0x22, 0x2D, 0x8B, 0xA4, 0xB9, 0x35, 0xAC, 0xA4, 0x4F, 0x41, 0x12, 0x9A, 0x69, 0xB4, + 0xB0, 0x89, 0xBE, 0xEF, 0xBC, 0xB2, 0x9C, 0xF2, 0x85, 0xD3, 0x59, 0x20, 0x13, 0x25, 0xD6, 0xA0, + 0xC4, 0xD5, 0x75, 0x49, 0x30, 0x78, 0xE4, 0x21, 0xA7, 0x78, 0xA3, 0xCD, 0xAA, 0xC7, 0x08, 0x93, + 0x3A, 0xD4, 0x38, 0xF8, 0x49, 0xFE, 0x8F, 0x5A, 0x37, 0xD6, 0xC8, 0x20, 0x24, 0xC9, 0x52, 0x34, + 0x98, 0x92, 0x41, 0xA0, 0x01, 0x6C, 0x25, 0xDE, 0x7D, 0xAF, 0x9F, 0xA7, 0x3D, 0x3D, 0x58, 0x88, + 0xBD, 0xAB, 0x2C, 0xF9, 0x22, 0xCE, 0xE5, 0xB1, 0x10, 0xFF, 0x6C, 0xF7, 0xFC, 0xF6, 0xD8, 0x62, + 0x85, 0xC9, 0xA3, 0x03, 0x78, 0xD3, 0x0B, 0x51, 0xC4, 0x5F, 0xC6, 0x1D, 0xFF, 0xCA, 0xFB, 0xFD, + 0xF6, 0x35, 0xFF, 0x7B, 0x08, 0xB6, 0xFF, 0xB3, 0xF5, 0x73, 0x75, 0x4F, 0x7E, 0x1A, 0xE2, 0x14, + 0xF0, 0xF1, 0x5F, 0x27, 0x64, 0x1C, 0x10, 0x08, 0xAC, 0x6F, 0x3B, 0x5E, 0x33, 0x6C, 0xCC, 0x82, + 0x10, 0x14, 0xD3, 0xB6, 0x2C, 0x39, 0xC1, 0xA2, 0x46, 0x32, 0x3C, 0x60, 0x4E, 0x46, 0x8B, 0x28, + 0x08, 0x45, 0x00, 0x9B, 0xBF, 0xE0, 0x01, 0x50, 0x52, 0xBA, 0x26, 0x33, 0x85, 0x46, 0x3C, 0x52, + 0xB5, 0x64, 0x28, 0x7E, 0xD4, 0xE7, 0xE7, 0x50, 0x16, 0xD0, 0x56, 0x8A, 0xED, 0x82, 0x7E, 0x04, + 0x71, 0x15, 0xA1, 0x9A, 0x56, 0x93, 0xBA, 0x11, 0xAE, 0x4D, 0xB0, 0x77, 0x4E, 0xB8, 0x8C, 0x01, + 0x2D, 0xA1, 0x1D, 0xDF, 0xB3, 0x5F, 0x01, 0x85, 0xA8, 0x16, 0x1C, 0x45, 0xC9, 0x98, 0xF8, 0xD1, + 0xEB, 0xBE, 0x2E, 0x39, 0xA9, 0x18, 0xAB, 0xCD, 0x1E, 0xDA, 0x1C, 0xBB, 0x55, 0xA2, 0x8B, 0x5F, + 0x42, 0xF3, 0xDB, 0xDF, 0xA3, 0xD6, 0x37, 0xCD, 0x37, 0xBD, 0xBF, 0xF5, 0x48, 0x00, 0x0A, 0x92, + 0xA0, 0x96, 0x03, 0x15, 0x61, 0x2E, 0xD0, 0x03, 0x66, 0xA7, 0xDE, 0x7D, 0x2B, 0x11, 0x76, 0x00, + 0x3B, 0x3C, 0x6B, 0x7F, 0x10, 0x1C, 0xC7, 0x01, 0x39, 0x5E, 0x37, 0x85, 0x82, 0x65, 0x52, 0x38, + 0xBF, 0x23, 0x97, 0x89, 0xDF, 0x34, 0xC5, 0x16, 0x8C, 0x4D, 0xC0, 0x67, 0x86, 0xE8, 0xE7, 0xEA, + 0x8C, 0x20, 0x68, 0xAB, 0x52, 0xA5, 0x51, 0x34, 0xD5, 0x02, 0x2A, 0xBE, 0xA0, 0x21, 0x11, 0x81, + 0x77, 0xC6, 0x71, 0x05, 0x28, 0xB1, 0x87, 0x88, 0x06, 0x2E, 0x4E, 0x15, 0x0B, 0x80, 0x6D, 0x89, + 0x80, 0x49, 0x86, 0x45, 0x40, 0x03, 0x94, 0xC6, 0x2E, 0x29, 0x1A, 0x59, 0x5E, 0x68, 0xD1, 0xF0, + 0x5C, 0x9E, 0x61, 0x41, 0xD0, 0x54, 0xAA, 0x0D, 0x0E, 0x32, 0x80, 0xA8, 0x08, 0x72, 0x73, 0x1C, + 0x56, 0x6B, 0x0D, 0xA4, 0x6A, 0x6A, 0xB7, 0xEB, 0xF2, 0x1D, 0xF7, 0xC5, 0x80, 0x83, 0x01, 0x2B, + 0x05, 0xFF, 0x57, 0x41, 0x98, 0x38, 0x8A, 0x62, 0xC1, 0xDA, 0x9C, 0x00, 0xD7, 0x5B, 0x80, 0xD0, + 0x92, 0xFF, 0xFB, 0x92, 0x64, 0xFB, 0x8E, 0x04, 0xF9, 0x30, 0xC5, 0x8B, 0x99, 0x5B, 0xD0, 0x48, + 0x64, 0xBA, 0x3D, 0x20, 0x26, 0x89, 0xCF, 0x54, 0xBD, 0x1E, 0x4D, 0x6D, 0x0B, 0xC0, 0xF1, 0x8C, + 0xE7, 0x64, 0x21, 0x88, 0xB6, 0x87, 0x6C, 0xB8, 0x00, 0x43, 0x54, 0xF4, 0x11, 0xF8, 0x47, 0xE6, + 0xD8, 0x3E, 0x08, 0xE4, 0xD0, 0x17, 0x7E, 0x53, 0x93, 0x6A, 0x78, 0xBE, 0xDE, 0xE4, 0x87, 0xB2, + 0xE1, 0x77, 0x87, 0x12, 0x15, 0x4E, 0xCC, 0xB5, 0x0B, 0x2E, 0x46, 0x35, 0xA3, 0xD6, 0x11, 0x22, + 0xF7, 0x05, 0x34, 0x2C, 0xEA, 0x55, 0x62, 0xEE, 0xEA, 0x73, 0xA1, 0x7D, 0x50, 0x00, 0xB6, 0xA9, + 0x62, 0x23, 0x76, 0x22, 0x10, 0x75, 0x6C, 0xAD, 0x33, 0x20, 0xC2, 0x03, 0x0A, 0x02, 0x23, 0xF3, + 0xD2, 0xCA, 0x18, 0x36, 0x5D, 0xBF, 0x2B, 0x2A, 0x60, 0x92, 0xCB, 0x3A, 0x17, 0x6B, 0xC3, 0x73, + 0x1D, 0xE2, 0x77, 0x8B, 0xC7, 0xBA, 0x72, 0x07, 0x6B, 0x3B, 0x55, 0x97, 0x49, 0x60, 0x45, 0x6B, + 0x98, 0x16, 0x33, 0x7D, 0x8C, 0x74, 0x24, 0x02, 0x00, 0x04, 0x0E, 0xA6, 0xE1, 0x98, 0x8B, 0xC2, + 0x8F, 0x89, 0x71, 0x46, 0x87, 0xE1, 0xCD, 0x92, 0x2A, 0x26, 0x42, 0xDA, 0x3F, 0xAF, 0x14, 0xB1, + 0x74, 0x42, 0x64, 0x60, 0x90, 0x20, 0x64, 0x03, 0xB0, 0x94, 0x0E, 0x05, 0x2D, 0xDD, 0x6B, 0x21, + 0x99, 0x77, 0x18, 0xD5, 0x15, 0x06, 0x46, 0x53, 0x9E, 0xFE, 0x93, 0xF2, 0x1E, 0xCD, 0x53, 0x13, + 0xD1, 0x95, 0x9A, 0x95, 0x08, 0xF0, 0xE7, 0xF9, 0x98, 0x49, 0x8A, 0x25, 0xF1, 0x8A, 0x46, 0x10, + 0x34, 0x96, 0x45, 0x36, 0x33, 0x47, 0xEC, 0xB3, 0x62, 0x05, 0x36, 0x0D, 0x73, 0x49, 0x9C, 0xB9, + 0x82, 0xCC, 0x9C, 0xBF, 0xAF, 0xA4, 0x53, 0x00, 0xB0, 0x03, 0x6D, 0xB8, 0x16, 0x57, 0x21, 0x4F, + 0x74, 0xDC, 0xC2, 0x5C, 0xA9, 0xE3, 0x0B, 0x82, 0x58, 0xD8, 0x39, 0xE7, 0xD3, 0xBF, 0xE5, 0x73, + 0xE1, 0x95, 0x4B, 0xAD, 0xC1, 0x83, 0xE6, 0x15, 0x3A, 0x28, 0xFF, 0x72, 0x1E, 0x71, 0x48, 0xF8, + 0xC4, 0xB5, 0x77, 0xE4, 0x4F, 0x11, 0x79, 0x93, 0x23, 0x89, 0xA1, 0x44, 0x5A, 0x66, 0x35, 0xEA, + 0x80, 0x00, 0x02, 0x8B, 0x96, 0xEA, 0xA4, 0xC9, 0x85, 0x89, 0x0B, 0x36, 0xB1, 0xC3, 0x03, 0x55, + 0x3B, 0x62, 0x40, 0x81, 0x23, 0x6C, 0x27, 0x32, 0xD0, 0x03, 0x0B, 0x20, 0x02, 0x11, 0xB0, 0xE3, + 0x15, 0x0F, 0x33, 0x9A, 0x12, 0xD9, 0xA0, 0x8C, 0xB4, 0x46, 0x08, 0x13, 0x1A, 0x65, 0xA9, 0x3A, + 0xB0, 0xEE, 0xA5, 0x29, 0x9D, 0x1A, 0x06, 0x82, 0x30, 0x1B, 0x4A, 0x7C, 0x5E, 0x36, 0x43, 0x1C, + 0x87, 0xE0, 0x88, 0xF5, 0xB2, 0xDC, 0x07, 0x50, 0x10, 0xD7, 0xF0, 0x38, 0x5B, 0x2D, 0x3A, 0xF7, + 0x69, 0x8E, 0x09, 0x11, 0x14, 0x04, 0xED, 0x98, 0xA9, 0x46, 0x25, 0x9B, 0xEA, 0x42, 0x10, 0x50, + 0x5C, 0xF1, 0x63, 0xCB, 0xED, 0xA9, 0x70, 0xB3, 0x64, 0x52, 0xF3, 0x82, 0xC2, 0xF3, 0x6A, 0x62, + 0xCD, 0x0B, 0x12, 0xFF, 0xFB, 0x92, 0x64, 0xEB, 0x00, 0x04, 0x74, 0x2F, 0x46, 0x0B, 0x99, 0x4C, + 0x40, 0x3A, 0x23, 0x0A, 0x09, 0x04, 0x02, 0x73, 0x8C, 0x04, 0xC5, 0x3D, 0x8C, 0x20, 0x4F, 0xB0, + 0xE9, 0x07, 0xA7, 0x28, 0x01, 0x8C, 0x12, 0x51, 0x47, 0xC4, 0xE8, 0x38, 0xE5, 0x86, 0x77, 0x33, + 0x4F, 0xD5, 0xD4, 0x08, 0x88, 0xF2, 0x46, 0x34, 0x93, 0x1D, 0x64, 0x3B, 0x50, 0x92, 0x91, 0xDD, + 0xAC, 0xF8, 0xB0, 0x4C, 0x7B, 0xF6, 0xD5, 0x6A, 0xAD, 0x56, 0x7E, 0xFB, 0xFA, 0x3A, 0xB8, 0xB5, + 0x72, 0x1C, 0x86, 0x29, 0x1C, 0xCA, 0x2D, 0xDE, 0x8C, 0x88, 0x7F, 0x37, 0xA1, 0xF9, 0x2A, 0x12, + 0x64, 0x62, 0xD1, 0x4E, 0x64, 0x43, 0x32, 0xDF, 0xB7, 0x17, 0xF7, 0x51, 0x15, 0x41, 0xA2, 0x54, + 0x84, 0x79, 0xD3, 0xDA, 0x07, 0x6D, 0x81, 0x06, 0xF4, 0x48, 0x01, 0x14, 0xE4, 0x9C, 0x7F, 0x94, + 0xA4, 0xD4, 0x29, 0x12, 0xA2, 0x20, 0x12, 0x14, 0x8E, 0x6B, 0xA1, 0x08, 0x9E, 0x1E, 0xB3, 0xC0, + 0x60, 0x82, 0x12, 0x21, 0x72, 0x02, 0x33, 0x00, 0x41, 0x66, 0x7F, 0xC1, 0x85, 0x1A, 0x2D, 0x24, + 0x84, 0x18, 0x62, 0x26, 0x48, 0xD3, 0xD5, 0xAC, 0x39, 0xBA, 0x81, 0x3F, 0x70, 0x1B, 0xA5, 0x61, + 0xFA, 0x55, 0x36, 0x4D, 0x4F, 0x07, 0x13, 0x07, 0x94, 0x5B, 0x6E, 0xAC, 0x1E, 0xCD, 0xE8, 0xC5, + 0x27, 0xCD, 0x34, 0x0F, 0x3A, 0x9C, 0xC8, 0x5A, 0x88, 0xC0, 0xD3, 0xE7, 0xD4, 0x48, 0x5C, 0x4C, + 0xAC, 0x1C, 0x7F, 0xB7, 0x38, 0x8E, 0x8C, 0x8D, 0xCA, 0x71, 0x31, 0x84, 0x10, 0x75, 0x1A, 0x08, + 0xDA, 0xDF, 0xFE, 0x7C, 0xFD, 0x23, 0x5F, 0x7F, 0x78, 0xD8, 0x65, 0xC7, 0x1F, 0x5F, 0xC4, 0x0E, + 0xA0, 0x9B, 0x5F, 0xCF, 0x3E, 0xFA, 0x3F, 0xC3, 0xB0, 0x7F, 0x36, 0xAE, 0x8C, 0xF2, 0x17, 0xEC, + 0xEA, 0x7F, 0x0F, 0x20, 0x58, 0x20, 0x78, 0x75, 0x2C, 0x7C, 0x84, 0x0C, 0x13, 0xF4, 0xB5, 0xAF, + 0x23, 0x6E, 0xEB, 0x4F, 0xD1, 0x6D, 0x0A, 0xC6, 0x14, 0x71, 0x2C, 0x61, 0x23, 0xA9, 0x5D, 0x3E, + 0x8B, 0xD6, 0xE8, 0xE8, 0x5B, 0xD7, 0x72, 0xBA, 0x3D, 0xDD, 0x1D, 0x90, 0x8E, 0xA3, 0x9D, 0x9E, + 0x8E, 0x49, 0x1F, 0x39, 0x13, 0xBB, 0x1E, 0x8B, 0xF4, 0xD9, 0x8D, 0x7C, 0x8B, 0x5F, 0xBD, 0x92, + 0xC3, 0x32, 0xCD, 0x8F, 0x30, 0x55, 0x19, 0x05, 0xAA, 0x09, 0x37, 0x05, 0x12, 0x85, 0x8D, 0x22, + 0x6F, 0x30, 0x30, 0x14, 0xC0, 0xE1, 0x73, 0x09, 0x13, 0x8D, 0x7F, 0x7D, 0x32, 0xC2, 0x60, 0xC8, + 0x61, 0xE3, 0x23, 0x01, 0x8C, 0x38, 0x66, 0x30, 0x41, 0xF0, 0xCC, 0x23, 0xB4, 0xE2, 0x3A, 0x12, + 0x5C, 0xC2, 0x42, 0x03, 0x1E, 0x82, 0x52, 0xD4, 0xF7, 0x48, 0x14, 0x5A, 0x82, 0x8C, 0xCE, 0x03, + 0x59, 0x29, 0x10, 0x0E, 0xA8, 0x4B, 0x2C, 0xBA, 0xED, 0x99, 0x02, 0x90, 0x8C, 0xEC, 0x54, 0x26, + 0x15, 0x58, 0xD1, 0x92, 0x07, 0x42, 0x73, 0x31, 0x96, 0x2E, 0xEA, 0x1A, 0xFE, 0xED, 0x2B, 0xB5, + 0xD8, 0xC2, 0xC8, 0x00, 0x2E, 0xFF, 0xFB, 0x92, 0x64, 0xF8, 0x8C, 0x03, 0xF7, 0x2E, 0xC9, 0x3B, + 0x6C, 0x2C, 0xB0, 0x46, 0xCA, 0x1A, 0x2A, 0x08, 0x23, 0xF5, 0xD1, 0x48, 0xC5, 0x22, 0x6D, 0x30, + 0xB8, 0x09, 0x11, 0x25, 0xA7, 0xE4, 0x80, 0x0A, 0x8E, 0xFB, 0x2B, 0x73, 0x27, 0xE8, 0xE0, 0x30, + 0x04, 0x1E, 0x07, 0x61, 0xC8, 0xBA, 0x89, 0x11, 0x1E, 0x6F, 0xAD, 0xEC, 0xD1, 0x97, 0xFF, 0x1D, + 0x5A, 0x92, 0x23, 0x33, 0x07, 0x44, 0x72, 0x2B, 0x85, 0x8C, 0xB8, 0x71, 0x7A, 0x93, 0xED, 0x01, + 0x0A, 0xB1, 0x84, 0xAC, 0x4A, 0x9B, 0x75, 0x8A, 0x77, 0x16, 0xBB, 0xCC, 0x33, 0xB2, 0xAB, 0xBD, + 0x76, 0xB0, 0x52, 0x90, 0x50, 0x1D, 0xB1, 0xB6, 0x3C, 0x08, 0x85, 0x3C, 0xEE, 0xA1, 0x2C, 0xBD, + 0xAF, 0x80, 0xC9, 0x01, 0xB0, 0xC2, 0x7F, 0x62, 0x43, 0x89, 0xFF, 0xFD, 0x9F, 0x7E, 0xD7, 0x3D, + 0x2C, 0xAC, 0xCA, 0x32, 0x95, 0xD2, 0x73, 0x87, 0x05, 0x05, 0x01, 0x8D, 0xA2, 0x36, 0x99, 0x14, + 0x63, 0xC2, 0xC7, 0x57, 0xBC, 0x48, 0x40, 0x5E, 0x75, 0x16, 0xE5, 0x85, 0x3D, 0xF3, 0x5E, 0xA0, + 0x08, 0x7B, 0xCE, 0xE9, 0x7C, 0xC2, 0x0C, 0x53, 0x25, 0x95, 0x2C, 0x19, 0xB0, 0x4E, 0x9B, 0x58, + 0x99, 0x93, 0x05, 0xAD, 0xE3, 0x15, 0x13, 0x0C, 0x15, 0x32, 0x40, 0x13, 0x79, 0x49, 0x1B, 0xAB, + 0x16, 0x19, 0x64, 0x8B, 0xCC, 0x89, 0x05, 0x30, 0xD5, 0x84, 0x60, 0x55, 0x94, 0xC4, 0x53, 0xAC, + 0xB9, 0x0D, 0xD8, 0xD1, 0xDA, 0x49, 0x4B, 0x20, 0xEE, 0x0A, 0x34, 0x71, 0x94, 0x8F, 0x24, 0xCF, + 0x17, 0x0E, 0x43, 0xED, 0x0F, 0x77, 0x83, 0x46, 0x34, 0xA2, 0x50, 0x08, 0x50, 0xB5, 0x7B, 0xA0, + 0x00, 0x1F, 0x0A, 0x28, 0xF4, 0xC4, 0xD1, 0x05, 0x32, 0xC3, 0xCE, 0xB3, 0x15, 0x35, 0x0D, 0x1C, + 0x92, 0x7D, 0xD4, 0xD7, 0x43, 0xDC, 0xF3, 0x21, 0x92, 0x21, 0x16, 0x4B, 0x35, 0x9D, 0x6D, 0xBD, + 0x70, 0xD3, 0xF4, 0x31, 0x14, 0x68, 0xBB, 0xAA, 0xB6, 0x00, 0x02, 0x00, 0x80, 0xB2, 0x34, 0xC4, + 0x40, 0x4C, 0x92, 0x25, 0x3F, 0xBD, 0xE4, 0xCB, 0xFF, 0xED, 0x9C, 0xB7, 0x89, 0x85, 0x00, 0x26, + 0x0D, 0x91, 0x6B, 0xE9, 0x12, 0x03, 0x06, 0x43, 0x2A, 0xC9, 0x32, 0xB5, 0x8C, 0x2C, 0xD0, 0x99, + 0x42, 0x06, 0xE6, 0xB4, 0xF6, 0xF6, 0x7D, 0x05, 0xE7, 0x2B, 0xA6, 0xBA, 0xA0, 0x00, 0x13, 0x5F, + 0x34, 0xC6, 0x44, 0x02, 0x8D, 0x41, 0xA0, 0x40, 0x54, 0x79, 0x04, 0x23, 0x34, 0xFB, 0x05, 0x43, + 0x18, 0x40, 0x8D, 0x1C, 0x20, 0xE0, 0x96, 0x22, 0xC2, 0x33, 0x0E, 0xBC, 0x7E, 0xA2, 0x6D, 0x19, + 0x32, 0x48, 0x1C, 0xD4, 0x5C, 0x55, 0x90, 0x93, 0xA9, 0xC8, 0xE9, 0x2D, 0xF2, 0x78, 0x4F, 0xDE, + 0xAE, 0x56, 0x1C, 0x72, 0x92, 0x18, 0x08, 0x5C, 0xE7, 0xF8, 0xA0, 0x4F, 0xA3, 0x8E, 0xE5, 0xC2, + 0x7E, 0x23, 0x66, 0x17, 0x6F, 0x0C, 0xB2, 0x9D, 0x19, 0xBD, 0xB6, 0xC5, 0x1B, 0x41, 0x0F, 0x0A, + 0x69, 0xCA, 0xAC, 0xF6, 0x5A, 0x23, 0x77, 0xFF, 0xFB, 0x92, 0x64, 0xED, 0x0C, 0x04, 0x9B, 0x31, + 0x46, 0x0B, 0x99, 0x43, 0xD0, 0x3F, 0x24, 0xAA, 0x8D, 0x3D, 0x22, 0x1B, 0x8F, 0x08, 0x8B, 0x20, + 0x4D, 0xBC, 0x72, 0xC0, 0xCF, 0x0E, 0xE9, 0xF4, 0x70, 0x0A, 0xCE, 0xFA, 0xD6, 0x83, 0x90, 0x72, + 0xEE, 0x39, 0xDA, 0xCA, 0xB7, 0xA6, 0xAF, 0x5B, 0x3D, 0x58, 0xBF, 0xAF, 0x67, 0xEE, 0x5F, 0x4D, + 0x08, 0x70, 0x00, 0x08, 0x81, 0x2D, 0xDF, 0x0A, 0x05, 0xC6, 0x66, 0x37, 0xCD, 0x82, 0x3A, 0x4D, + 0xE0, 0x65, 0xAA, 0x42, 0x34, 0x81, 0x19, 0x2A, 0xAC, 0x1C, 0x64, 0xA9, 0x20, 0x97, 0xEE, 0xC5, + 0xCA, 0xE9, 0x76, 0xF6, 0x93, 0x41, 0x53, 0x25, 0x25, 0xEE, 0x22, 0xF3, 0x6B, 0x4A, 0x45, 0x17, + 0x0A, 0x09, 0x04, 0x05, 0x43, 0xE8, 0x38, 0x12, 0x72, 0x8D, 0x3C, 0xCA, 0x89, 0x2E, 0xA8, 0xBA, + 0x2E, 0x1D, 0x62, 0xE0, 0x00, 0x01, 0x5A, 0xAA, 0x38, 0xB1, 0x13, 0x7F, 0x12, 0x2B, 0x02, 0x03, + 0x2D, 0x84, 0x13, 0x00, 0x67, 0x0E, 0x01, 0x1C, 0x42, 0x12, 0x95, 0x26, 0x06, 0x34, 0x23, 0x0D, + 0x0E, 0x41, 0x31, 0x23, 0x71, 0x2A, 0x30, 0x30, 0x71, 0x60, 0x54, 0x9D, 0x00, 0xF3, 0x97, 0x49, + 0xBA, 0x21, 0xD5, 0x84, 0xBE, 0xEF, 0xA0, 0x80, 0x41, 0xCE, 0xA7, 0x6E, 0x30, 0x33, 0x60, 0x76, + 0x1D, 0x35, 0x22, 0xE8, 0x75, 0x7C, 0x3E, 0x4C, 0xD2, 0x91, 0xDB, 0x4B, 0x8C, 0xF4, 0xE5, 0xDE, + 0xAB, 0x59, 0x78, 0xD3, 0xB7, 0x8F, 0x9D, 0x2D, 0xC3, 0x89, 0x51, 0x50, 0x5D, 0xD1, 0x45, 0x07, + 0xA4, 0xA1, 0x66, 0xAE, 0x82, 0x1C, 0x6B, 0xFB, 0xAA, 0x88, 0x1E, 0xD1, 0xC2, 0x29, 0x94, 0xA2, + 0xC4, 0x29, 0x42, 0xAA, 0x0C, 0xE2, 0xAF, 0xCB, 0x5E, 0xA1, 0x38, 0xD1, 0xAC, 0x4A, 0x49, 0x26, + 0x62, 0xCA, 0x50, 0xD5, 0x92, 0xDE, 0x85, 0xD2, 0xD3, 0x1A, 0x39, 0x43, 0x00, 0x16, 0xAD, 0x0B, + 0x74, 0xBB, 0x40, 0x06, 0x46, 0x56, 0x94, 0x13, 0xED, 0x36, 0xD8, 0xDD, 0xCF, 0x04, 0x20, 0x71, + 0x43, 0xE1, 0x9C, 0x32, 0x71, 0x3F, 0xC5, 0x9D, 0x7A, 0x4C, 0x1D, 0x26, 0xA4, 0x4D, 0x30, 0x0A, + 0xE3, 0xE0, 0x98, 0xAB, 0xCA, 0x96, 0x7E, 0xD0, 0x2D, 0x5B, 0x0B, 0xA8, 0xC8, 0x12, 0x94, 0xCF, + 0x5F, 0x52, 0x52, 0x4A, 0xA6, 0x8F, 0xD6, 0x79, 0xD4, 0xEB, 0x4F, 0x46, 0x8A, 0x00, 0x48, 0x58, + 0x8B, 0xC4, 0x30, 0x13, 0x34, 0x10, 0xB4, 0xC6, 0x81, 0x53, 0x05, 0x81, 0x8C, 0x88, 0x45, 0x31, + 0x2C, 0x4C, 0xC0, 0x25, 0x43, 0x0D, 0x8E, 0x84, 0x00, 0x83, 0x13, 0x13, 0x4C, 0x36, 0x1E, 0x31, + 0x28, 0xB8, 0x08, 0x27, 0x38, 0x91, 0x1A, 0x22, 0x08, 0x0B, 0x98, 0x98, 0x72, 0x1C, 0x86, 0x6A, + 0x63, 0xC0, 0x07, 0x78, 0x0E, 0x45, 0xB6, 0xC4, 0xC4, 0x68, 0xB6, 0xF4, 0xBF, 0xCB, 0x4D, 0xD4, + 0x76, 0x55, 0x44, 0xD6, 0x57, 0xB6, 0x65, 0x7B, 0x2F, 0xC8, 0x06, 0x95, 0x34, 0x64, 0x75, 0x2F, + 0xBB, 0x9D, 0x91, 0x38, 0x08, 0x26, 0x06, 0xB5, 0x83, 0xFF, 0xFB, 0x92, 0x64, 0xEC, 0x84, 0x03, + 0x7D, 0x2F, 0x49, 0x33, 0x4F, 0x14, 0xB0, 0x43, 0xA1, 0x29, 0xBD, 0x0D, 0xE9, 0x14, 0x10, 0xE0, + 0xC3, 0x1F, 0x2D, 0xE0, 0xAF, 0x41, 0x09, 0x06, 0x67, 0xF4, 0x54, 0x8C, 0xC4, 0xBA, 0x50, 0xED, + 0x58, 0x80, 0xE4, 0x40, 0x40, 0x28, 0x8B, 0x31, 0x07, 0xB9, 0x0C, 0xDA, 0x95, 0x54, 0x53, 0x2A, + 0xA7, 0xD6, 0x71, 0xF1, 0x50, 0x70, 0x06, 0x2A, 0xE3, 0x02, 0x89, 0x7B, 0x4D, 0x2C, 0x65, 0xBD, + 0xED, 0xD5, 0x6E, 0x91, 0x5B, 0x58, 0xBA, 0x7A, 0xE4, 0x8C, 0x0F, 0xAD, 0x65, 0x49, 0x74, 0x9E, + 0x9A, 0xC0, 0x80, 0x00, 0x08, 0x00, 0x27, 0xDB, 0xFF, 0x60, 0x35, 0xAE, 0xD6, 0x28, 0xC1, 0xA1, + 0x6C, 0x6F, 0x08, 0x14, 0x7F, 0x8E, 0x29, 0x3C, 0xAB, 0x9A, 0xFF, 0xE6, 0xDB, 0xC7, 0x29, 0x82, + 0xC9, 0x17, 0x58, 0xD3, 0xF4, 0x2C, 0xAA, 0x98, 0x78, 0x9B, 0x9B, 0xAA, 0xC6, 0x25, 0xF9, 0xA7, + 0x80, 0xCA, 0x95, 0xB2, 0x52, 0x7A, 0x61, 0x3A, 0x1D, 0x4A, 0xD5, 0xB5, 0x5E, 0x8B, 0x3A, 0xD3, + 0x4C, 0x00, 0x02, 0xDB, 0x71, 0xEE, 0x9F, 0x43, 0x10, 0x50, 0x92, 0x94, 0x00, 0xE4, 0x47, 0x3A, + 0x32, 0x1B, 0x98, 0x91, 0xE4, 0x26, 0x40, 0xCA, 0x81, 0x42, 0x41, 0xC6, 0x42, 0xE8, 0x8C, 0x2B, + 0x14, 0xA7, 0x30, 0xA6, 0x84, 0x02, 0xC1, 0x44, 0x1F, 0xBC, 0x98, 0x1A, 0x86, 0xEE, 0xA3, 0xC7, + 0xA5, 0xC6, 0x4A, 0xE6, 0x26, 0xE2, 0x78, 0xC4, 0xB2, 0xB9, 0xC4, 0xEC, 0xAE, 0xFA, 0xF4, 0xAF, + 0xBF, 0xC7, 0x70, 0xF9, 0x75, 0xCA, 0xD6, 0x73, 0x0E, 0x9C, 0xAB, 0xDE, 0xF3, 0xA2, 0xBD, 0xAB, + 0xEB, 0xEC, 0x94, 0x01, 0x1F, 0x7F, 0x7F, 0xB9, 0xDD, 0x1F, 0xA3, 0x65, 0x8D, 0x55, 0x6C, 0xD7, + 0x9E, 0xF4, 0x52, 0x00, 0x00, 0x20, 0xE2, 0x52, 0xC8, 0xE0, 0xE9, 0x96, 0xD8, 0x34, 0xB3, 0x36, + 0xE7, 0x49, 0xCD, 0x24, 0xF2, 0xE3, 0x0E, 0x8B, 0x1F, 0xC9, 0xAE, 0x0A, 0x20, 0x23, 0x34, 0x97, + 0x3D, 0x42, 0x6B, 0x45, 0x50, 0x13, 0xDB, 0xA8, 0xE8, 0xE2, 0xBB, 0xF6, 0x6A, 0x55, 0xD4, 0xFC, + 0x74, 0xB2, 0xC0, 0xF4, 0xA7, 0xEE, 0xDB, 0xD5, 0xDA, 0x31, 0x9D, 0x95, 0x97, 0x36, 0x14, 0xCC, + 0x33, 0x53, 0x04, 0x49, 0xDC, 0x20, 0x1B, 0x98, 0xA4, 0xE8, 0x64, 0x99, 0x71, 0xA8, 0x90, 0x06, + 0x9A, 0x46, 0x1A, 0x34, 0x14, 0x64, 0x04, 0xE9, 0x10, 0xFC, 0xCD, 0x29, 0x63, 0x4F, 0x16, 0x4D, + 0x7A, 0x7A, 0x2E, 0xD9, 0x84, 0xC0, 0xC3, 0xD1, 0x1F, 0x82, 0x99, 0x83, 0xB9, 0x61, 0x48, 0xC4, + 0xE6, 0x49, 0xD2, 0x8A, 0x04, 0x66, 0x21, 0x0A, 0xAC, 0x93, 0x02, 0x07, 0x4C, 0xC5, 0xAC, 0xCC, + 0xD1, 0xCE, 0x05, 0x52, 0xC2, 0xAA, 0x04, 0x4B, 0x35, 0xE5, 0xD2, 0xF8, 0xBF, 0x8E, 0xAC, 0x71, + 0x98, 0xC1, 0xFB, 0x7D, 0x44, 0x2A, 0x38, 0xE8, 0xE3, 0x3C, 0xD2, 0x62, 0xC3, 0xC2, 0x81, 0xC4, + 0x11, 0x27, 0xAA, 0xBB, 0x21, 0xAC, 0x74, 0x99, 0xC5, 0x32, 0xE7, 0xFF, 0xFB, 0x92, 0x64, 0xED, + 0x04, 0x04, 0x80, 0x2F, 0x47, 0x13, 0x98, 0x2C, 0x40, 0x3F, 0xA1, 0x89, 0xCD, 0x24, 0x23, 0x30, + 0x0C, 0x30, 0xB9, 0x28, 0xED, 0x30, 0xB2, 0xC0, 0xE5, 0x19, 0xE7, 0xB4, 0x90, 0x8A, 0x3C, 0x9E, + 0xE1, 0x48, 0x98, 0xDD, 0xD7, 0x47, 0xE9, 0xC2, 0x62, 0x3A, 0x92, 0x13, 0x12, 0xA8, 0x4F, 0x07, + 0xD2, 0xF1, 0x05, 0x84, 0xAA, 0x52, 0xC2, 0x22, 0xDA, 0x4D, 0x25, 0x88, 0x28, 0xF7, 0x2E, 0x28, + 0x59, 0xFC, 0xED, 0xAA, 0xEC, 0xD1, 0x6F, 0x44, 0x82, 0x9A, 0x0E, 0x49, 0x1B, 0x63, 0xAE, 0x4D, + 0x05, 0x2B, 0x08, 0xA7, 0x3D, 0xF4, 0xE2, 0x2A, 0x80, 0xD3, 0x0E, 0x14, 0x39, 0xFF, 0xF9, 0x79, + 0x21, 0xE5, 0x21, 0x5A, 0xE6, 0x7E, 0xDA, 0xE5, 0xD2, 0xD7, 0x35, 0x52, 0x85, 0x6B, 0x6B, 0x9F, + 0xC6, 0x92, 0xB9, 0x3A, 0x3A, 0x6C, 0x76, 0xBB, 0x5A, 0x67, 0x0F, 0xE3, 0xCA, 0xF4, 0x86, 0x22, + 0x40, 0x9A, 0x13, 0x62, 0xAC, 0x78, 0x41, 0x49, 0x52, 0x05, 0x31, 0x73, 0x08, 0x21, 0x65, 0x24, + 0x00, 0x01, 0x76, 0xDF, 0xF4, 0x4A, 0x19, 0x6B, 0x45, 0x81, 0x0F, 0x0D, 0xC2, 0x58, 0x51, 0x60, + 0x82, 0x9A, 0x68, 0x5C, 0x58, 0x90, 0x0A, 0xAC, 0xCE, 0xCC, 0x44, 0x69, 0x90, 0xEA, 0x94, 0x84, + 0x85, 0x77, 0xB8, 0x86, 0x32, 0x5F, 0x02, 0x76, 0x56, 0x42, 0xCB, 0xD0, 0xB4, 0xEA, 0xDA, 0x9D, + 0x6E, 0x72, 0xE6, 0xED, 0x8C, 0x45, 0x5D, 0x68, 0x89, 0xD3, 0x96, 0x03, 0x12, 0x02, 0xC8, 0x24, + 0x16, 0xB6, 0x49, 0x2C, 0x8C, 0xBF, 0x8B, 0x24, 0xBC, 0x95, 0xC7, 0xDF, 0xFE, 0xB8, 0x5C, 0xDA, + 0x01, 0x48, 0xB6, 0xF0, 0x48, 0xA8, 0xB5, 0xF3, 0xB7, 0x77, 0x24, 0x96, 0x77, 0x53, 0xD5, 0xA2, + 0x01, 0xA0, 0x2B, 0x0A, 0xC1, 0xA8, 0x1F, 0x38, 0xFA, 0xCE, 0x4D, 0x65, 0x96, 0xFE, 0x66, 0xD4, + 0x0C, 0x7F, 0xF7, 0xB5, 0x0A, 0x7B, 0x3E, 0xA1, 0x76, 0x50, 0xE3, 0xC1, 0x12, 0x05, 0xC3, 0xA4, + 0x0E, 0x25, 0xE2, 0x6A, 0xB5, 0x8D, 0xAD, 0xC8, 0x18, 0x80, 0x4C, 0x1C, 0x51, 0x37, 0x25, 0x17, + 0xCC, 0x43, 0x40, 0xD3, 0x6A, 0xEA, 0xA1, 0xA9, 0x80, 0x00, 0x00, 0x00, 0x52, 0xAE, 0x39, 0x6A, + 0xB6, 0x0C, 0x00, 0x9E, 0x5E, 0x12, 0x5A, 0x18, 0xC0, 0xE1, 0x84, 0x9A, 0x99, 0xF0, 0x88, 0xCA, + 0x29, 0xB4, 0xB5, 0x18, 0xB0, 0x88, 0x73, 0x51, 0xA5, 0x23, 0x18, 0x90, 0x91, 0xDB, 0xA0, 0x19, + 0xA9, 0x0B, 0xE8, 0x66, 0x2E, 0xDD, 0x8C, 0x45, 0x14, 0xE5, 0x7F, 0x8C, 0x2A, 0x4D, 0x3D, 0x33, + 0x5A, 0x1C, 0x05, 0x0D, 0xED, 0xC8, 0xD5, 0xB4, 0x2E, 0x1A, 0xE9, 0x63, 0x48, 0x77, 0xAD, 0x1B, + 0x5F, 0x66, 0x70, 0x36, 0x24, 0x73, 0xEF, 0xE4, 0x07, 0x8B, 0x22, 0x78, 0x55, 0x8A, 0xBA, 0x9F, + 0x64, 0xB1, 0x2B, 0x15, 0x9E, 0x37, 0xA1, 0xFF, 0x87, 0x70, 0xA6, 0xA7, 0xB3, 0x8D, 0x2C, 0xAB, + 0xBA, 0x6D, 0xAC, 0x4D, 0x74, 0xBC, 0x4B, 0x21, 0x25, 0x50, 0xEA, 0xAB, 0xE8, 0xFF, 0xFB, 0x92, + 0x64, 0xF6, 0x84, 0x04, 0xAF, 0x2E, 0x45, 0x83, 0x99, 0x5B, 0xD0, 0x48, 0xC7, 0x7A, 0x6D, 0x3C, + 0x23, 0x4F, 0x8C, 0x08, 0xA5, 0x33, 0xAC, 0x30, 0x4F, 0x40, 0xE4, 0x85, 0x67, 0xA4, 0x21, 0x98, + 0x0E, 0x1B, 0xF4, 0x0A, 0x02, 0xFD, 0x8D, 0x80, 0xFC, 0xB9, 0x17, 0x13, 0x63, 0x94, 0x40, 0x61, + 0x86, 0x1E, 0xD9, 0x50, 0x1C, 0xC0, 0xE3, 0x65, 0x16, 0x85, 0x6C, 0x78, 0xEA, 0x54, 0xB5, 0xAE, + 0xA9, 0x86, 0x45, 0x5D, 0x17, 0x28, 0x35, 0xA9, 0x27, 0x99, 0xCA, 0x34, 0x6F, 0x0A, 0x68, 0xF6, + 0xA7, 0x3A, 0x38, 0x44, 0x99, 0x78, 0x7E, 0xA8, 0x77, 0xCA, 0xAF, 0xE3, 0x2E, 0xF5, 0xF8, 0xF9, + 0xA9, 0x3E, 0x00, 0x02, 0x00, 0x20, 0x01, 0x96, 0x5D, 0x85, 0x0A, 0x22, 0x1A, 0x4B, 0x24, 0x42, + 0xA8, 0xA8, 0x0C, 0x86, 0x51, 0x8D, 0xA1, 0xB9, 0x35, 0x4A, 0x67, 0xD6, 0x6E, 0x1B, 0x15, 0xF5, + 0xFD, 0x4F, 0x00, 0x97, 0x46, 0xE7, 0xEA, 0xE7, 0xCE, 0x9D, 0x75, 0xF1, 0x93, 0x5B, 0x56, 0xAD, + 0x01, 0x4A, 0xC9, 0xAC, 0x6D, 0x07, 0x05, 0xE5, 0x4D, 0x89, 0x12, 0xAB, 0xED, 0x48, 0xC8, 0x78, + 0xD2, 0x19, 0x36, 0x94, 0xD2, 0x3A, 0x00, 0x00, 0x00, 0x04, 0xA4, 0x8E, 0x01, 0x55, 0x68, 0x70, + 0xE8, 0x01, 0x22, 0x01, 0x36, 0x10, 0x34, 0xDD, 0x6A, 0x2F, 0xC8, 0x18, 0x12, 0xA3, 0x31, 0xC2, + 0xD5, 0x44, 0x44, 0xBC, 0x18, 0x20, 0xCD, 0x8F, 0x2F, 0x91, 0x85, 0x0C, 0x77, 0x80, 0xAA, 0xD2, + 0x58, 0x49, 0x68, 0xCE, 0xC4, 0x13, 0xF4, 0x87, 0x3E, 0xAA, 0x8D, 0x9A, 0x3A, 0x9E, 0x33, 0x8C, + 0x47, 0xA9, 0x58, 0x91, 0x3C, 0xD8, 0xEA, 0x75, 0x1C, 0x77, 0x31, 0xF0, 0xA7, 0x8D, 0x35, 0x28, + 0x00, 0xED, 0xF7, 0xF9, 0x4B, 0xFF, 0xFF, 0x76, 0x2C, 0x30, 0xEA, 0xAA, 0x31, 0x0D, 0x77, 0xB9, + 0x77, 0xE3, 0xBA, 0xBD, 0xB9, 0x5A, 0xBA, 0x56, 0xE1, 0x8E, 0xFF, 0x7C, 0x08, 0x00, 0x01, 0x00, + 0x2E, 0x96, 0x30, 0x12, 0x9B, 0x83, 0x0C, 0x8B, 0x04, 0xCA, 0x4A, 0x92, 0x6F, 0xFF, 0x50, 0xC3, + 0xC2, 0x85, 0x4B, 0x91, 0x6D, 0x31, 0x64, 0x09, 0xE9, 0x73, 0x98, 0xFA, 0xD2, 0x39, 0x22, 0x04, + 0x5A, 0x42, 0x67, 0xAE, 0x9F, 0xB5, 0x1C, 0x76, 0x98, 0x84, 0xD8, 0xE6, 0x92, 0x58, 0xF2, 0x55, + 0x2A, 0x80, 0x00, 0x00, 0x00, 0x13, 0x6E, 0x3A, 0xD0, 0x18, 0xE8, 0x83, 0x36, 0x39, 0x26, 0x41, + 0x49, 0x82, 0xA8, 0x42, 0xCA, 0x8E, 0x81, 0xE2, 0xF8, 0x88, 0x03, 0x1B, 0xF5, 0x8F, 0xA1, 0x84, + 0x2C, 0x42, 0x34, 0xE8, 0xA0, 0x30, 0x61, 0xCC, 0xD8, 0x24, 0xC4, 0x44, 0x68, 0x19, 0x73, 0x29, + 0x7A, 0x59, 0x4C, 0xBB, 0x74, 0x27, 0x1B, 0xC2, 0x3C, 0x88, 0xC9, 0x8B, 0x83, 0x13, 0xA3, 0x45, + 0x45, 0xF2, 0x52, 0x96, 0x8C, 0xE5, 0x18, 0xD2, 0x07, 0x17, 0x34, 0x0C, 0x95, 0x96, 0x6A, 0xF4, + 0x24, 0x05, 0x1C, 0xFB, 0x96, 0x27, 0x5C, 0xC6, 0xEC, 0x74, 0xEB, 0x44, 0xB6, 0x82, 0x51, 0xFF, + 0xFB, 0x92, 0x64, 0xF9, 0x84, 0x05, 0xAE, 0x65, 0x46, 0xD3, 0x79, 0x43, 0x70, 0x44, 0x04, 0xF9, + 0x9D, 0x24, 0x23, 0x98, 0x0C, 0xBC, 0xC5, 0x29, 0xAD, 0x3C, 0x4F, 0x40, 0xD2, 0x01, 0xA8, 0x70, + 0x90, 0x8C, 0x06, 0x20, 0x51, 0x01, 0xA2, 0xEA, 0x39, 0x39, 0x23, 0x48, 0x98, 0x63, 0xB4, 0xD6, + 0xC8, 0xCB, 0xED, 0x43, 0x5A, 0x1B, 0x5E, 0xC6, 0x25, 0xE0, 0x07, 0xF9, 0xBA, 0x75, 0xB7, 0x62, + 0x20, 0x00, 0x00, 0x08, 0x06, 0xDA, 0x93, 0x62, 0x2E, 0x0A, 0x2F, 0x0A, 0x1C, 0xA7, 0x29, 0x1B, + 0x13, 0x24, 0xE8, 0xA8, 0xD6, 0x8D, 0xD9, 0x29, 0xF4, 0xC8, 0xA7, 0x55, 0x3D, 0x83, 0x9C, 0xAA, + 0x49, 0xFC, 0x12, 0x26, 0x54, 0x1C, 0x6E, 0x51, 0x20, 0x5C, 0xE5, 0xC3, 0x23, 0x4C, 0x2D, 0x6C, + 0x48, 0x79, 0xAB, 0x7F, 0xD1, 0xED, 0x59, 0xA3, 0xF4, 0xC5, 0x12, 0x77, 0x7D, 0xE8, 0x54, 0x85, + 0x1F, 0xF1, 0x5B, 0xAA, 0x26, 0x42, 0x0D, 0x99, 0x46, 0x20, 0x86, 0x0A, 0xA6, 0x04, 0x04, 0xC6, + 0x0A, 0x0A, 0xE6, 0x52, 0x49, 0xA6, 0x6E, 0x18, 0x26, 0x4A, 0x8D, 0x88, 0x4F, 0x30, 0xF9, 0x11, + 0x05, 0x0D, 0xC6, 0x40, 0x89, 0x26, 0x36, 0x97, 0x66, 0x30, 0x29, 0xC0, 0x22, 0x30, 0x99, 0x3B, + 0x0E, 0xF0, 0xA7, 0xA2, 0xD1, 0xB3, 0x34, 0xD0, 0x16, 0xEA, 0x74, 0x04, 0x24, 0xF2, 0x1A, 0x2B, + 0x36, 0x42, 0xA2, 0xA8, 0xBB, 0x4B, 0xA7, 0x0E, 0x69, 0x03, 0x11, 0x21, 0xA4, 0x2E, 0xD4, 0x26, + 0xB8, 0xF2, 0xE4, 0x42, 0x8B, 0xB3, 0x47, 0x44, 0x68, 0x99, 0xD9, 0x78, 0x32, 0x15, 0x56, 0xB7, + 0x2F, 0x53, 0x26, 0xA6, 0x0E, 0x01, 0x27, 0xAF, 0x94, 0x17, 0x59, 0x26, 0x98, 0x53, 0xFC, 0xFF, + 0x7B, 0x70, 0x47, 0x0F, 0x8A, 0x6D, 0xFA, 0x86, 0xEA, 0xA2, 0x3E, 0x5C, 0x8C, 0x76, 0xCD, 0x70, + 0x28, 0x79, 0x87, 0xD4, 0xF0, 0x26, 0x3D, 0x26, 0x5A, 0xFC, 0xFC, 0xED, 0x43, 0xC3, 0xEA, 0x2C, + 0x72, 0x35, 0x99, 0xB9, 0x26, 0xBD, 0x8D, 0x72, 0x1A, 0x53, 0x63, 0xD6, 0xB2, 0xF4, 0x38, 0xC3, + 0x00, 0x26, 0xDC, 0x90, 0x43, 0x0C, 0x80, 0x15, 0x47, 0x40, 0xB5, 0xE3, 0x53, 0xA2, 0x81, 0x00, + 0x11, 0x14, 0x7F, 0x57, 0xED, 0x9B, 0x32, 0x6C, 0x3B, 0x29, 0x34, 0x48, 0xB0, 0xE4, 0x65, 0xD2, + 0xE4, 0x0F, 0xD3, 0x43, 0xC6, 0x97, 0x53, 0x02, 0x92, 0xC7, 0x98, 0x74, 0x28, 0x6D, 0x41, 0x55, + 0x97, 0xB9, 0x01, 0xC2, 0x00, 0x48, 0xC1, 0x49, 0xFD, 0xA2, 0x47, 0x21, 0x36, 0x55, 0x80, 0x00, + 0x08, 0x0D, 0x92, 0x8D, 0x83, 0x4C, 0x90, 0x31, 0x2F, 0xC0, 0xF3, 0x10, 0xAA, 0x73, 0xD0, 0x00, + 0xD0, 0xA5, 0x33, 0x01, 0x4C, 0xF9, 0x93, 0x3F, 0x78, 0x49, 0x50, 0x51, 0x59, 0xA3, 0x08, 0x76, + 0x92, 0x87, 0x10, 0x37, 0xE3, 0x08, 0x47, 0x91, 0x48, 0x5B, 0xF5, 0xD8, 0x51, 0x30, 0xF6, 0x86, + 0xF6, 0x4C, 0xBC, 0x50, 0x25, 0x76, 0x37, 0x15, 0x7F, 0xD8, 0x0A, 0xB2, 0xBC, 0x93, 0x89, 0xB9, + 0x08, 0xFF, 0xFB, 0x92, 0x64, 0xEE, 0x04, 0x43, 0xDA, 0x31, 0xC9, 0x53, 0x4C, 0x2C, 0xB0, 0x42, + 0x41, 0x39, 0x6A, 0x31, 0xE9, 0x24, 0x13, 0x74, 0xC1, 0x14, 0x0E, 0xE5, 0x2F, 0x40, 0xFC, 0x02, + 0xA7, 0x74, 0x27, 0xB0, 0x02, 0x8D, 0x19, 0xCC, 0x49, 0x4C, 0xCA, 0xA8, 0x36, 0x07, 0x00, 0x28, + 0xEA, 0x49, 0x65, 0x54, 0x2B, 0xF0, 0x13, 0x4E, 0xEC, 0xED, 0xBA, 0xC8, 0x52, 0xE8, 0xEF, 0xFA, + 0x17, 0x13, 0xF7, 0xF9, 0x8F, 0xF1, 0x4F, 0xF6, 0xEA, 0xFC, 0x75, 0x3A, 0x37, 0x22, 0xD6, 0x49, + 0x2D, 0x17, 0x39, 0xD0, 0x00, 0x00, 0x10, 0x2C, 0xC2, 0x9E, 0x00, 0x7D, 0x98, 0x93, 0x43, 0x99, + 0x1A, 0x20, 0x88, 0x7B, 0xEF, 0xFF, 0xFD, 0x6B, 0xFE, 0xBF, 0xEB, 0xD7, 0x35, 0xA8, 0xB7, 0xE8, + 0xA8, 0x18, 0xE8, 0xB4, 0x5C, 0x38, 0x74, 0xD0, 0x13, 0xBA, 0x37, 0x6D, 0x41, 0x2C, 0xAE, 0x93, + 0xB0, 0xDB, 0x77, 0x5D, 0xDC, 0xF0, 0x3C, 0xEB, 0xC0, 0x1C, 0x94, 0x7C, 0xC0, 0x42, 0xB3, 0x33, + 0x9E, 0xD2, 0xB1, 0x09, 0x23, 0x03, 0x03, 0x49, 0xD1, 0x8D, 0x1C, 0x0E, 0x32, 0x39, 0xB9, 0x1F, + 0x80, 0x87, 0x93, 0x08, 0x83, 0xCC, 0x2C, 0xF5, 0x30, 0xD0, 0x20, 0xDD, 0x00, 0x35, 0xA1, 0xF0, + 0xCF, 0x75, 0x0C, 0xC3, 0x53, 0x49, 0x57, 0x4B, 0xC1, 0x0B, 0x33, 0xF5, 0xC9, 0x30, 0xDB, 0x29, + 0x63, 0xA0, 0xA5, 0x2C, 0x89, 0xF9, 0x5B, 0x22, 0xA0, 0xA7, 0x2C, 0x3A, 0xD1, 0xA7, 0x61, 0xF5, + 0x49, 0x0F, 0xBC, 0xF0, 0x03, 0xFD, 0x2C, 0x5E, 0x50, 0x7D, 0x45, 0x94, 0xAF, 0xD8, 0xDB, 0xE9, + 0x01, 0xC2, 0xDA, 0x05, 0x0C, 0x18, 0xFB, 0xB2, 0x94, 0x19, 0x1B, 0x2B, 0xEB, 0x7F, 0x11, 0xFF, + 0x7C, 0xFC, 0xC6, 0xE3, 0x24, 0xD6, 0x79, 0x1A, 0x21, 0x27, 0xA8, 0x8C, 0x69, 0x92, 0xD6, 0xD7, + 0xCD, 0x59, 0x9E, 0xEB, 0xDB, 0x2C, 0x45, 0x74, 0xEE, 0xE5, 0x3F, 0x6D, 0x68, 0x14, 0x80, 0x00, + 0x00, 0x0B, 0x00, 0x0D, 0x8E, 0x5D, 0xC5, 0x52, 0xF3, 0x94, 0xC7, 0xE2, 0x43, 0xC8, 0x25, 0x04, + 0xB8, 0xA4, 0x2F, 0x17, 0x0B, 0x69, 0x89, 0x81, 0x15, 0xC1, 0x90, 0x22, 0x7F, 0xA3, 0xF7, 0x43, + 0x62, 0xC3, 0xC8, 0x06, 0x5E, 0x72, 0xB5, 0x24, 0x1E, 0x38, 0x81, 0x6D, 0x2D, 0xDB, 0xA0, 0x5D, + 0xAF, 0x4A, 0xF5, 0x33, 0xCE, 0x0E, 0x75, 0x31, 0x6D, 0x5D, 0xCC, 0xD9, 0xA6, 0x72, 0xF7, 0xF6, + 0x25, 0x20, 0x00, 0x01, 0x13, 0x29, 0xE3, 0x13, 0x5E, 0x46, 0x90, 0x74, 0x5E, 0x81, 0x10, 0x00, + 0x81, 0x44, 0xD7, 0xEB, 0x4C, 0x88, 0x2C, 0xCB, 0x04, 0xC3, 0x85, 0x0B, 0x05, 0xC6, 0x36, 0x12, + 0x90, 0xE6, 0x68, 0x42, 0x66, 0x65, 0x80, 0x10, 0x92, 0xDD, 0xA5, 0x88, 0x71, 0x35, 0x89, 0x4E, + 0x04, 0x20, 0x2E, 0xAC, 0x94, 0x7C, 0x3A, 0x52, 0x40, 0x1E, 0x74, 0x75, 0x32, 0x07, 0x1E, 0x88, + 0xC5, 0x41, 0x7C, 0xD0, 0x8A, 0xA9, 0xAF, 0x7D, 0x8E, 0x4C, 0x78, 0x15, 0x93, 0xD5, 0xC2, 0x82, + 0x61, 0xF1, 0xAD, 0xFF, 0xFB, 0x92, 0x64, 0xE0, 0x84, 0x03, 0x86, 0x2E, 0xC8, 0x33, 0x4C, 0x15, + 0x90, 0x35, 0x85, 0x29, 0xFC, 0x3C, 0x22, 0x1F, 0x90, 0xB8, 0xBB, 0x18, 0x2E, 0x65, 0x6D, 0x81, + 0x0B, 0x07, 0xE6, 0x74, 0x61, 0x26, 0x00, 0x6A, 0x86, 0x7F, 0xEA, 0x68, 0x68, 0x84, 0xFD, 0x2C, + 0xBF, 0xBB, 0xE2, 0x41, 0x8C, 0x8D, 0x5D, 0xE1, 0x44, 0x95, 0x8C, 0x36, 0x81, 0x8F, 0xFD, 0xBF, + 0xFE, 0x95, 0x75, 0xE8, 0xB9, 0x76, 0x5D, 0x14, 0xAF, 0x70, 0xC4, 0xC6, 0x00, 0x2E, 0x00, 0x4D, + 0xB7, 0x21, 0x28, 0xE8, 0xAE, 0xD5, 0x20, 0x4A, 0x91, 0xFC, 0x14, 0x2D, 0xEC, 0x10, 0x97, 0x69, + 0x20, 0x50, 0xD1, 0xC3, 0xCC, 0x45, 0xAC, 0x61, 0xE6, 0x96, 0x72, 0x4F, 0xB1, 0x92, 0x71, 0x46, + 0x2C, 0xC1, 0x36, 0x31, 0x29, 0xB9, 0x59, 0x09, 0x90, 0x72, 0xE5, 0x5C, 0xAB, 0x84, 0xEE, 0xBB, + 0xFF, 0x22, 0xAC, 0xC5, 0x8E, 0xEE, 0xFE, 0xCF, 0xD5, 0x90, 0x09, 0xC9, 0x2F, 0xD2, 0x98, 0x01, + 0x46, 0x1E, 0x29, 0x92, 0x18, 0x0E, 0x38, 0x5A, 0x93, 0x3D, 0xB4, 0x31, 0x11, 0x85, 0x26, 0xB1, + 0x46, 0x53, 0x91, 0x18, 0x26, 0x0E, 0x17, 0x08, 0x72, 0x03, 0x80, 0x40, 0x90, 0x92, 0x2F, 0xA3, + 0x82, 0xD1, 0x5E, 0x0F, 0xE5, 0x33, 0x4A, 0x9C, 0xE5, 0xBE, 0x99, 0x1D, 0x4D, 0xBB, 0xC2, 0x99, + 0x88, 0xC3, 0x4B, 0x32, 0x31, 0x7F, 0xF5, 0x34, 0x16, 0x61, 0xA4, 0x8C, 0x8F, 0x35, 0xE7, 0x04, + 0xE2, 0x4A, 0x94, 0x24, 0x8D, 0x96, 0x97, 0xB2, 0x5E, 0x8F, 0xFC, 0x26, 0x16, 0x5B, 0x66, 0x63, + 0x73, 0x7F, 0x4E, 0xCA, 0xCE, 0xEB, 0x04, 0x25, 0x4A, 0xDA, 0x47, 0x3A, 0xCF, 0x28, 0xD5, 0xE8, + 0x6E, 0x5C, 0x51, 0xB8, 0xF2, 0x45, 0x94, 0xED, 0x15, 0x00, 0xCF, 0xA5, 0xEB, 0x06, 0x40, 0x04, + 0x04, 0xA2, 0x4D, 0xC9, 0x83, 0xA9, 0x15, 0x4B, 0x00, 0x70, 0x96, 0x3E, 0x0B, 0x86, 0xD6, 0x46, + 0x08, 0xC2, 0x91, 0xD1, 0x9B, 0x46, 0xB3, 0xAB, 0xF8, 0xA2, 0x57, 0xF5, 0x16, 0x9C, 0x36, 0x2E, + 0x3F, 0x46, 0x5F, 0x46, 0xA3, 0xB5, 0xC4, 0x9E, 0xC0, 0x98, 0xC5, 0xD2, 0xD5, 0xAB, 0xB5, 0x8F, + 0xE4, 0xB8, 0xC2, 0x45, 0x93, 0x54, 0xDA, 0xB5, 0xEF, 0xDF, 0xFE, 0xEE, 0xFA, 0x6C, 0xF2, 0x0F, + 0xED, 0x02, 0xE8, 0xD2, 0xD0, 0xCE, 0x49, 0xCE, 0xCC, 0x58, 0x08, 0x2C, 0x44, 0x6C, 0x61, 0x0B, + 0x46, 0x2B, 0xC4, 0x6E, 0xE4, 0x46, 0x02, 0xF0, 0x19, 0x50, 0x62, 0x8A, 0xE6, 0x62, 0x30, 0x62, + 0x00, 0xA0, 0xAE, 0xD0, 0xCA, 0x33, 0x23, 0x61, 0x33, 0x71, 0xD0, 0xE2, 0x30, 0x12, 0xAD, 0x84, + 0xF7, 0x03, 0x04, 0x13, 0x06, 0xBA, 0x14, 0x69, 0x88, 0xC3, 0x9E, 0xE6, 0x60, 0xE2, 0xCE, 0x4A, + 0xA4, 0x60, 0x50, 0x3A, 0x52, 0xF0, 0x87, 0x00, 0xBE, 0x3B, 0x0E, 0x91, 0x6A, 0xAC, 0x7D, 0xB3, + 0x97, 0x34, 0x5A, 0x3C, 0x08, 0xE0, 0x4B, 0x9F, 0xE9, 0x76, 0x28, 0x07, 0x79, 0xD6, 0x9C, 0xB5, + 0xDE, 0x3F, 0x81, 0x11, 0xE3, 0xFF, 0xFB, 0x92, 0x64, 0xE8, 0x06, 0x03, 0xB1, 0x2F, 0x48, 0xBB, + 0x6C, 0x1C, 0xB0, 0x3D, 0xC1, 0x59, 0x7A, 0x04, 0x46, 0x00, 0x0E, 0x84, 0xF9, 0x27, 0x4D, 0x3C, + 0x4F, 0x41, 0x10, 0x12, 0x65, 0xA8, 0xC1, 0x95, 0x50, 0x87, 0xB9, 0xDF, 0x7B, 0xF7, 0x5B, 0xF5, + 0x85, 0xAA, 0x92, 0x2C, 0xD0, 0x49, 0x82, 0xC2, 0x30, 0xF1, 0x94, 0x0B, 0xCD, 0x89, 0x81, 0xD7, + 0xBD, 0xA9, 0x6C, 0xB7, 0x0D, 0x80, 0x07, 0x84, 0x05, 0x4C, 0x05, 0x5E, 0x39, 0x57, 0x8F, 0xA6, + 0x1A, 0x8A, 0xAD, 0x6E, 0xC8, 0xF4, 0xC5, 0xCE, 0xD4, 0xC0, 0x00, 0x00, 0x14, 0xAC, 0x76, 0xA1, + 0xAE, 0x4E, 0x10, 0xF3, 0xF5, 0x60, 0x59, 0x8B, 0x19, 0x75, 0x53, 0x39, 0x35, 0xA2, 0xD5, 0x89, + 0xF5, 0x95, 0xF7, 0x51, 0x77, 0xC8, 0x7C, 0x4E, 0xBE, 0x0C, 0x61, 0x0B, 0x9F, 0xEF, 0xAA, 0xCD, + 0xE7, 0x9F, 0x0D, 0x24, 0x14, 0x7C, 0xBC, 0x60, 0xB2, 0x84, 0xA0, 0x32, 0x6F, 0x1D, 0x16, 0x7D, + 0x88, 0xAB, 0xEA, 0x9B, 0xA1, 0x5D, 0x15, 0xA7, 0xBB, 0xA6, 0xAE, 0xD8, 0x03, 0x78, 0x26, 0x06, + 0x30, 0x64, 0x33, 0x4A, 0x91, 0x03, 0x1F, 0x33, 0xE3, 0x0D, 0xFB, 0xF5, 0x54, 0x38, 0x4A, 0x0D, + 0x03, 0xD3, 0x0A, 0x64, 0xD2, 0x4C, 0x2E, 0x99, 0x82, 0x20, 0x12, 0xF4, 0xCB, 0x92, 0x33, 0xB0, + 0x57, 0xA8, 0x92, 0x70, 0x10, 0xFA, 0xCB, 0x6C, 0x40, 0x60, 0xBE, 0x6F, 0x64, 0x3E, 0x07, 0x64, + 0xBE, 0xD5, 0x0E, 0xD0, 0x6A, 0x72, 0x7E, 0x18, 0x25, 0x81, 0x5C, 0x92, 0x35, 0xCA, 0x34, 0xEB, + 0x1B, 0x34, 0xD9, 0x64, 0x7E, 0xAF, 0xD0, 0x83, 0x81, 0xE1, 0x3F, 0x2B, 0x87, 0xDB, 0xFC, 0xFD, + 0x45, 0x83, 0xB7, 0x80, 0x67, 0x1A, 0x6E, 0xB8, 0xFB, 0xEC, 0x36, 0x48, 0x07, 0xE8, 0x55, 0x7F, + 0xEE, 0x17, 0xAB, 0x98, 0x52, 0xEB, 0x9D, 0xCF, 0xFE, 0xFF, 0xAA, 0xD6, 0x0A, 0x00, 0x60, 0x19, + 0x75, 0x7B, 0x84, 0xA9, 0xF4, 0x7D, 0x7A, 0x21, 0x95, 0xE1, 0xBB, 0x6C, 0x33, 0xFF, 0x5C, 0x35, + 0xDC, 0x5D, 0x67, 0x14, 0x34, 0xE9, 0xEC, 0xC9, 0xF1, 0x96, 0x0D, 0x1E, 0x74, 0x9B, 0x11, 0x8A, + 0xBE, 0xD6, 0x98, 0x02, 0xFD, 0x07, 0x55, 0xD8, 0x95, 0xD7, 0xE9, 0xBF, 0xD4, 0xE3, 0x29, 0x16, + 0x16, 0x35, 0x84, 0x03, 0x9D, 0x1B, 0x30, 0x10, 0x13, 0x07, 0x9F, 0x39, 0x48, 0xF3, 0x16, 0xA9, + 0x3E, 0x57, 0x83, 0x7B, 0x16, 0x33, 0x18, 0x73, 0x01, 0x18, 0x0A, 0xB0, 0x1E, 0xFB, 0xB9, 0xF2, + 0xA3, 0x9A, 0x88, 0x99, 0xA6, 0x05, 0x18, 0xC9, 0x01, 0x90, 0x83, 0x24, 0x5B, 0x39, 0x2A, 0x15, + 0x1A, 0x78, 0xBA, 0x00, 0x97, 0x82, 0x19, 0x13, 0x07, 0xD2, 0xA3, 0xA3, 0x77, 0x85, 0x36, 0x65, + 0xE2, 0x08, 0x13, 0x6C, 0x0C, 0x6E, 0xB2, 0x83, 0xAF, 0xA5, 0x88, 0xE0, 0xBC, 0x10, 0x2E, 0x4B, + 0x0E, 0x8A, 0x94, 0xCB, 0xB1, 0xF8, 0x58, 0x8E, 0x9C, 0x69, 0xA8, 0xD1, 0x82, 0x28, 0x31, 0xCD, + 0x97, 0x1D, 0x47, 0x90, 0x23, 0xE8, 0x62, 0xFF, 0xFB, 0x92, 0x64, 0xF1, 0x04, 0x04, 0x9F, 0x2F, + 0xC6, 0x0B, 0x6F, 0x2D, 0xA0, 0x42, 0xA4, 0x09, 0x49, 0x3C, 0x43, 0x86, 0x0E, 0x14, 0x81, 0x1E, + 0xAD, 0xE9, 0xE3, 0xC0, 0xC3, 0x0D, 0x28, 0xE4, 0x20, 0x0E, 0x1E, 0x93, 0xED, 0xB7, 0x1A, 0xC5, + 0x43, 0xDD, 0x76, 0xAC, 0x94, 0x6C, 0x64, 0x53, 0xD3, 0xCF, 0xE7, 0x2D, 0x60, 0xC5, 0x15, 0x9F, + 0xF1, 0x3F, 0xAF, 0x2C, 0x65, 0x47, 0xB3, 0x2F, 0xB3, 0x95, 0x95, 0xAF, 0x5F, 0xF6, 0xE7, 0xEB, + 0xE6, 0xF7, 0x1D, 0x65, 0x6F, 0xCF, 0xFD, 0x5A, 0xDF, 0x24, 0x6E, 0x20, 0x02, 0x2A, 0xBF, 0x9A, + 0xFD, 0xE2, 0xDD, 0x02, 0xDA, 0x2B, 0xE3, 0x9A, 0x1B, 0xBA, 0xC6, 0xDB, 0x3C, 0x9F, 0x7F, 0xC8, + 0x00, 0x8F, 0x91, 0xF3, 0x7D, 0x22, 0x0C, 0x08, 0xE2, 0xED, 0xB7, 0xD9, 0x2B, 0xB8, 0x80, 0xB8, + 0x2C, 0x49, 0x09, 0x66, 0xFA, 0xDA, 0xB8, 0xD5, 0xC8, 0xB1, 0x48, 0x8E, 0x50, 0x95, 0x6B, 0x50, + 0x02, 0x17, 0x12, 0xA4, 0xC9, 0xD4, 0x30, 0x83, 0x1B, 0x30, 0xB7, 0x8E, 0x6D, 0x63, 0xD2, 0xBB, + 0x7A, 0x29, 0xA9, 0x5F, 0x6C, 0x04, 0x00, 0x00, 0x04, 0x91, 0x75, 0xB7, 0x69, 0xC8, 0xFC, 0xB0, + 0x28, 0x42, 0x25, 0xCD, 0xAB, 0x81, 0x78, 0x1A, 0x71, 0x6C, 0xE1, 0x25, 0xEC, 0x86, 0xDF, 0xB4, + 0x15, 0x44, 0x44, 0xB7, 0x41, 0x01, 0x34, 0x60, 0xEA, 0x22, 0xB8, 0x16, 0x9C, 0x89, 0x3A, 0x56, + 0xB5, 0x4C, 0xE9, 0x06, 0xA2, 0x71, 0xB6, 0xDA, 0xD4, 0xFF, 0x84, 0x35, 0xB1, 0x93, 0x32, 0xF3, + 0xF3, 0x6B, 0x3F, 0xC4, 0xD7, 0x64, 0x4C, 0x64, 0x0B, 0x19, 0xAB, 0xBE, 0x28, 0xFE, 0x79, 0x56, + 0xFF, 0x5B, 0xF6, 0x6F, 0xDE, 0xE6, 0x54, 0xEE, 0x97, 0xB1, 0x8C, 0x7F, 0xDB, 0x6B, 0x09, 0x37, + 0xDE, 0x99, 0x68, 0x00, 0x00, 0x08, 0x06, 0x5B, 0x28, 0x03, 0x50, 0x84, 0xE1, 0xE8, 0x72, 0x2B, + 0x50, 0xE1, 0xC9, 0x21, 0x23, 0x02, 0xB0, 0xE4, 0x8A, 0x91, 0x0B, 0x56, 0xB5, 0xFF, 0xA4, 0x55, + 0x65, 0x2E, 0x48, 0xF4, 0x3C, 0xD8, 0xB9, 0x8B, 0x48, 0xDA, 0x36, 0x57, 0x1B, 0xD0, 0xFD, 0xF1, + 0x45, 0xA6, 0x17, 0x00, 0x0D, 0xA6, 0x54, 0x8D, 0x75, 0x81, 0x80, 0x00, 0x00, 0x00, 0x24, 0xB6, + 0x5B, 0x09, 0xDA, 0x53, 0x08, 0x08, 0x4B, 0x44, 0x48, 0x18, 0x80, 0xC1, 0x79, 0x1C, 0x52, 0x28, + 0x2C, 0x01, 0x98, 0x28, 0x19, 0x42, 0x82, 0x52, 0xBD, 0x3F, 0x94, 0xE0, 0x1A, 0x3A, 0x4E, 0x35, + 0x97, 0xE2, 0x37, 0x13, 0x28, 0x82, 0x5B, 0x36, 0x59, 0xFA, 0x1C, 0x9B, 0x26, 0x53, 0x09, 0xCD, + 0x10, 0xD6, 0x06, 0xF0, 0x38, 0xB1, 0xE9, 0xE6, 0x97, 0x49, 0xC8, 0xF2, 0xA5, 0x1B, 0xEB, 0xB9, + 0x14, 0xA5, 0x6E, 0xD3, 0x7D, 0xC2, 0x57, 0xDD, 0x25, 0x2E, 0x4A, 0xA2, 0xA3, 0xC9, 0xB4, 0x56, + 0x4E, 0x21, 0x5A, 0x40, 0x0E, 0x70, 0xA2, 0x2E, 0x78, 0xB1, 0xA1, 0xEE, 0x8A, 0x21, 0xF2, 0x19, + 0x17, 0x92, 0x11, 0x90, 0x63, 0x10, 0x05, 0xAE, 0xD4, 0xFF, 0xFB, 0x92, 0x64, 0xF4, 0x00, 0x04, + 0xC5, 0x27, 0xC5, 0x03, 0x6C, 0x1E, 0x82, 0x4B, 0x04, 0x6A, 0x1C, 0x3C, 0x23, 0x4F, 0x8B, 0x9C, + 0x81, 0x31, 0xAC, 0xB1, 0x2E, 0x40, 0xDB, 0x84, 0xA6, 0xB4, 0x16, 0x18, 0x10, 0xFB, 0x12, 0xB6, + 0x39, 0xB1, 0x5D, 0xF9, 0x44, 0x3E, 0xC0, 0x60, 0x00, 0x10, 0x56, 0xDB, 0x76, 0xDC, 0x1D, 0x4B, + 0x4A, 0x1F, 0x1D, 0x48, 0xC9, 0x12, 0x03, 0x60, 0x1B, 0x69, 0x5E, 0x33, 0x67, 0x1C, 0xCA, 0x4B, + 0x71, 0xB0, 0x73, 0x5E, 0xBE, 0x3C, 0x9E, 0x44, 0x48, 0xD9, 0xDE, 0xDF, 0x67, 0x98, 0x61, 0x53, + 0xC9, 0x0D, 0x3C, 0xA5, 0x33, 0x07, 0x81, 0x43, 0x97, 0xB0, 0x13, 0x5E, 0xA1, 0xFC, 0x24, 0x69, + 0x81, 0x06, 0x93, 0x3B, 0x1C, 0xFC, 0x51, 0x88, 0xDE, 0xA1, 0x88, 0x5C, 0x8A, 0xDF, 0x47, 0x65, + 0x69, 0xFA, 0xC1, 0x98, 0x66, 0x34, 0x4A, 0x11, 0xCF, 0x50, 0x15, 0x30, 0xC7, 0x01, 0x4F, 0x20, + 0xA9, 0xA7, 0xE0, 0x98, 0xA6, 0x8B, 0x86, 0xEA, 0x05, 0x80, 0xE6, 0x41, 0x59, 0xCE, 0x66, 0x61, + 0xD6, 0x0A, 0x9D, 0x0A, 0x0C, 0x25, 0x4C, 0x6C, 0xCC, 0x27, 0x39, 0x20, 0x41, 0x60, 0xE1, 0x80, + 0x68, 0x20, 0xD7, 0x91, 0x52, 0xC0, 0x28, 0x05, 0x77, 0x18, 0x96, 0x93, 0x99, 0xBE, 0x92, 0x35, + 0x95, 0x16, 0x55, 0xD2, 0x0A, 0x36, 0x05, 0x23, 0xAC, 0xFA, 0xD3, 0x38, 0x4F, 0xD4, 0x65, 0x91, + 0x38, 0xCE, 0x55, 0x0F, 0x2B, 0x90, 0x26, 0x81, 0xA7, 0x02, 0xB2, 0x0A, 0x4C, 0x36, 0xD6, 0x05, + 0x62, 0x5A, 0xD3, 0x4F, 0x4F, 0xFB, 0x17, 0x1A, 0xDA, 0x5A, 0x16, 0x9A, 0xB6, 0x73, 0x54, 0x96, + 0x7F, 0xE6, 0xBF, 0xFD, 0xCE, 0xAB, 0xB4, 0x88, 0x9A, 0x55, 0x55, 0xF5, 0x51, 0x78, 0x55, 0x57, + 0xED, 0x31, 0x3F, 0xAC, 0xBB, 0x6A, 0xBB, 0xF6, 0xEF, 0x2B, 0x47, 0xD3, 0x4B, 0xA9, 0x03, 0x55, + 0xC3, 0xD5, 0x57, 0xC2, 0x6F, 0xAA, 0x69, 0x0F, 0x03, 0xA6, 0x0A, 0xC0, 0x0F, 0xD9, 0x04, 0x87, + 0x37, 0xB8, 0x12, 0xA1, 0x72, 0x5A, 0x2F, 0x02, 0x25, 0x03, 0x62, 0x4F, 0xA5, 0x70, 0xE4, 0x49, + 0x4A, 0x62, 0xB5, 0x6B, 0xAA, 0xB8, 0xC0, 0xE1, 0xC3, 0x9E, 0x54, 0x0A, 0x54, 0x19, 0x11, 0x63, + 0x4E, 0xB1, 0x63, 0x5D, 0xC6, 0x9D, 0xF5, 0x11, 0x05, 0x5C, 0x25, 0x74, 0xD3, 0xDC, 0x0B, 0x1E, + 0x79, 0xE8, 0xB0, 0x76, 0x44, 0x4A, 0xB7, 0x48, 0x7E, 0xA6, 0x0A, 0xD9, 0x11, 0xBD, 0xFC, 0x1A, + 0x4C, 0x01, 0x02, 0xA1, 0xA9, 0xF8, 0x75, 0xC2, 0xE7, 0x32, 0x91, 0x8C, 0xF4, 0x1F, 0xD0, 0x85, + 0x78, 0x83, 0x08, 0x72, 0x8D, 0x7E, 0x49, 0x64, 0x5A, 0x92, 0x05, 0x50, 0x30, 0x1A, 0x8B, 0x84, + 0xBD, 0x11, 0x35, 0x07, 0x85, 0xA3, 0x4E, 0x73, 0x3C, 0x5A, 0x2E, 0x44, 0xE3, 0x4D, 0x85, 0xE6, + 0xCD, 0x1A, 0x2A, 0x2E, 0x37, 0x36, 0x68, 0xBB, 0x33, 0xA8, 0x89, 0xD4, 0x8B, 0x2D, 0x66, 0x4B, + 0x56, 0xEE, 0x9F, 0x01, 0x3D, 0x52, 0xDA, 0x3A, 0x87, 0xF2, 0xB9, 0xFF, 0xFB, 0x92, 0x64, 0xF7, + 0x04, 0x43, 0xC1, 0x23, 0xCA, 0x6B, 0x2C, 0x34, 0xB0, 0x4D, 0x24, 0x69, 0x9D, 0x30, 0x23, 0x6A, + 0x13, 0x24, 0xDD, 0x16, 0x2C, 0xE8, 0xCB, 0xC9, 0x12, 0x86, 0x64, 0x88, 0x27, 0xB0, 0x10, 0x2F, + 0xDB, 0xFF, 0xFE, 0x2A, 0x2C, 0x39, 0x0B, 0x00, 0x04, 0x62, 0xC8, 0x49, 0x89, 0x2E, 0xA5, 0x6A, + 0xC4, 0x84, 0xF6, 0x42, 0x24, 0x88, 0xA5, 0x21, 0xDA, 0x0F, 0xE4, 0x25, 0x43, 0x88, 0x52, 0xA7, + 0xB9, 0xA5, 0xCF, 0x5A, 0x5A, 0x7B, 0xF7, 0xAD, 0x82, 0x53, 0xA2, 0xA7, 0x64, 0xA5, 0x9E, 0xC4, + 0x96, 0xFE, 0x76, 0x76, 0xB7, 0x49, 0x89, 0x62, 0x5C, 0xED, 0xB9, 0xD9, 0x6F, 0xE7, 0x57, 0xB1, + 0x52, 0x2D, 0xAE, 0x1A, 0xFF, 0xA2, 0xE2, 0x59, 0x50, 0xFB, 0x72, 0x48, 0xBB, 0x0D, 0x1D, 0x80, + 0x68, 0xC0, 0x59, 0x70, 0x01, 0x24, 0x5F, 0xB1, 0x29, 0x53, 0xBC, 0xAA, 0xAB, 0x21, 0x2B, 0x99, + 0xD4, 0x6E, 0x03, 0x57, 0x32, 0x87, 0x29, 0xCA, 0x77, 0xAF, 0xDD, 0x7F, 0x7B, 0xA9, 0x74, 0x02, + 0xD7, 0x67, 0x7B, 0xCB, 0xF1, 0xAB, 0xB6, 0x6A, 0xD2, 0xF3, 0x2D, 0xD2, 0xCC, 0x2C, 0xB1, 0xA0, + 0x08, 0xA9, 0x92, 0x24, 0x2D, 0x72, 0xD4, 0x48, 0x5B, 0x63, 0x1E, 0xA8, 0x69, 0x5B, 0xD0, 0xC6, + 0x72, 0xB2, 0x95, 0x32, 0xE8, 0x6D, 0x15, 0x8C, 0xF5, 0xE6, 0x75, 0x64, 0xA0, 0x93, 0x21, 0xA5, + 0x6F, 0xD0, 0xDF, 0xD5, 0xB3, 0x29, 0x9D, 0x72, 0xCC, 0xAF, 0x99, 0xDB, 0x65, 0x2F, 0xBF, 0xFE, + 0xAA, 0xD9, 0xC7, 0x74, 0x7A, 0x9A, 0x87, 0x7F, 0x8B, 0x80, 0x0C, 0x29, 0x40, 0xBA, 0x10, 0xC7, + 0x1E, 0x3D, 0x62, 0x11, 0xE9, 0x13, 0xA0, 0x08, 0x06, 0x42, 0x52, 0x4B, 0x21, 0x0A, 0x41, 0x64, + 0x64, 0xB8, 0x58, 0x95, 0x38, 0x67, 0x11, 0x38, 0x4A, 0x77, 0x89, 0x7B, 0x3A, 0xCE, 0xF2, 0xDF, + 0xAB, 0xC2, 0x6E, 0xF4, 0x70, 0xED, 0x45, 0x57, 0xEA, 0x40, 0x76, 0x25, 0x1A, 0x1A, 0xB4, 0x35, + 0x56, 0xB9, 0x67, 0xFF, 0xFB, 0x72, 0x53, 0xDA, 0xC6, 0x11, 0xCB, 0x2A, 0x80, 0x01, 0x40, 0x02, + 0x99, 0x20, 0x80, 0x06, 0x0C, 0x99, 0xCC, 0x56, 0x6C, 0xF9, 0x1C, 0x92, 0xE7, 0x31, 0x19, 0x70, + 0x8B, 0xAA, 0x14, 0x26, 0x3C, 0x50, 0xC3, 0x8C, 0x32, 0x21, 0x87, 0x07, 0x86, 0x21, 0x2D, 0x33, + 0x3F, 0x46, 0x93, 0x00, 0x2D, 0x0C, 0x06, 0x81, 0x17, 0xB4, 0xBE, 0x2E, 0xC2, 0x97, 0x38, 0x32, + 0x44, 0x8E, 0x5E, 0x6C, 0x17, 0x70, 0x43, 0x5E, 0x82, 0xE0, 0x08, 0x19, 0x90, 0xBD, 0xB4, 0xD0, + 0xCC, 0xED, 0xEA, 0xF4, 0x51, 0xA6, 0x64, 0xC9, 0x8B, 0x9A, 0xDE, 0x46, 0x5D, 0x84, 0x01, 0x39, + 0xE6, 0x10, 0x4B, 0x3F, 0x68, 0x32, 0x28, 0xE3, 0x96, 0x8F, 0xB0, 0x54, 0xAD, 0x81, 0x03, 0x44, + 0x2B, 0x1B, 0xAB, 0x3D, 0xC9, 0xA9, 0xFB, 0x11, 0x2A, 0x4B, 0x58, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xF4, 0x54, 0x74, 0xC0, 0xE8, 0xB5, 0x09, 0xFC, 0x1B, 0x04, 0x80, 0x9C, 0xFF, 0xFB, 0x92, + 0x64, 0xE4, 0x0C, 0x02, 0x90, 0x24, 0xC0, 0x88, 0x6F, 0x30, 0xE0, 0x41, 0x82, 0x48, 0x32, 0x04, + 0xCC, 0x00, 0x0F, 0xB5, 0xB4, 0xDC, 0x2C, 0x15, 0x59, 0x80, 0xD4, 0x04, 0x1F, 0xE8, 0x14, 0x88, + 0x52, 0x1F, 0x00, 0x79, 0xC3, 0x2E, 0x8A, 0x28, 0xE2, 0x25, 0x85, 0xC4, 0x5E, 0x2F, 0x1A, 0x8A, + 0x00, 0x80, 0x01, 0xBE, 0x86, 0x6D, 0x83, 0x4C, 0x01, 0x16, 0x82, 0x12, 0x04, 0x36, 0x0C, 0x04, + 0x69, 0xA0, 0x81, 0x6B, 0x05, 0x21, 0x1B, 0x37, 0x82, 0xD0, 0x37, 0x46, 0x0B, 0x1A, 0x6A, 0x0E, + 0x15, 0x30, 0x14, 0x51, 0x66, 0x84, 0x2C, 0x1C, 0xA4, 0x18, 0x45, 0x8E, 0x84, 0x2A, 0x08, 0xF3, + 0x25, 0xA2, 0x7B, 0xDB, 0x93, 0x11, 0x94, 0xB4, 0x97, 0x11, 0xE6, 0x95, 0x38, 0xCB, 0xB6, 0x1E, + 0x44, 0xE6, 0x12, 0xD3, 0x13, 0xA9, 0x68, 0xBE, 0x52, 0xEA, 0xD5, 0xEA, 0xAD, 0x27, 0x5A, 0x81, + 0xF7, 0x7D, 0xA5, 0xAD, 0x65, 0x73, 0x6F, 0x07, 0x09, 0xD2, 0x5A, 0xD5, 0x19, 0x74, 0x35, 0x3C, + 0x4B, 0xFF, 0xFF, 0xDB, 0xFF, 0xFF, 0x85, 0x1F, 0x48, 0x88, 0x4A, 0x0B, 0x82, 0x21, 0xE1, 0xE1, + 0x49, 0xD3, 0xC2, 0xA5, 0xD4, 0x34, 0x02, 0x92, 0x06, 0x8E, 0x13, 0x26, 0x29, 0x60, 0x99, 0x36, + 0x02, 0xC5, 0x00, 0xD2, 0xE2, 0x97, 0x11, 0x37, 0x15, 0x5A, 0x55, 0x99, 0x79, 0x79, 0x75, 0x4B, + 0x1F, 0x0A, 0xA0, 0x15, 0x1D, 0x1D, 0x01, 0x8A, 0x13, 0x5D, 0xA1, 0x86, 0xC5, 0x26, 0x48, 0x9E, + 0xCE, 0x4A, 0xD9, 0x5B, 0x37, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDD, 0x4A, 0x12, 0x08, 0x49, + 0x8D, 0x4B, 0x12, 0x34, 0x46, 0x15, 0x89, 0x28, 0x88, 0x49, 0x42, 0xA1, 0x92, 0xC3, 0x68, 0xD2, + 0x7C, 0x71, 0x8E, 0x11, 0x1E, 0x28, 0x08, 0x71, 0x71, 0x9A, 0x8A, 0x26, 0x18, 0x12, 0xAE, 0x5A, + 0x0B, 0x72, 0x1E, 0x21, 0xA5, 0x90, 0xC6, 0x6D, 0x61, 0x4F, 0x2D, 0x1C, 0xAC, 0x88, 0x52, 0x25, + 0x1A, 0x87, 0x36, 0xA2, 0x57, 0x0B, 0x4F, 0x71, 0xEB, 0x97, 0xA8, 0x92, 0xE2, 0xA4, 0x08, 0x71, + 0x27, 0x02, 0x08, 0xC8, 0x12, 0xC0, 0x99, 0x2F, 0xE2, 0x1A, 0xB0, 0x41, 0x8C, 0xA2, 0xDC, 0x8B, + 0x2C, 0x2F, 0x73, 0x58, 0x3A, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xFF, + 0xFB, 0x92, 0x64, 0xFF, 0x84, 0x94, 0x80, 0x6C, 0xA9, 0xB3, 0x40, 0x8F, 0xB2, 0x67, 0xE3, 0xF5, + 0x05, 0x63, 0x59, 0x06, 0x0A, 0x1D, 0xB0, 0x90, 0x04, 0x80, 0xFE, 0xC9, 0x31, 0x10, 0xD1, 0x18, + 0x94, 0xBC, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x10, 0xD5, + 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x41, 0x8F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, + 0x20, 0x10, 0x00, 0x24, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, + 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, + 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, + 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, + 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, + 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, + 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, + 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, + 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, + 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x90, 0x64, 0x41, + 0x0F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, + 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, + 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, + 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, + 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, + 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, + 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, + 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, + 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, + 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, + 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, + 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, +}; +static const unsigned kAllahAkbarMp3Size = 85512; +// END_EMBEDDED_NOTIFICATION_SOUND + +std::wstring GetNotificationSoundPath() { + auto base = GetAppDataPrayerTrayPath(); + if (base.empty()) { + return L""; + } + return base + L"\\audio\\allah-akbar.mp3"; +} + +bool EnsureNotificationSoundFile() { + if (kAllahAkbarMp3Size == 0) { + Wh_Log(L"Notification sound missing embedded audio"); + return false; + } + auto path = GetNotificationSoundPath(); + if (path.empty()) { + Wh_Log(L"Notification sound path unavailable"); + return false; + } + auto base = GetAppDataPrayerTrayPath(); + CreateDirectoryW(base.c_str(), nullptr); + CreateDirectoryW((base + L"\\audio").c_str(), nullptr); + + WIN32_FILE_ATTRIBUTE_DATA attrs{}; + if (GetFileAttributesExW(path.c_str(), GetFileExInfoStandard, &attrs)) { + ULARGE_INTEGER size{}; + size.HighPart = attrs.nFileSizeHigh; + size.LowPart = attrs.nFileSizeLow; + if (size.QuadPart == kAllahAkbarMp3Size) { + return true; + } + } + + std::ofstream out(path.c_str(), std::ios::binary | std::ios::trunc); + if (!out) { + Wh_Log(L"Notification sound write failed"); + return false; + } + out.write(reinterpret_cast(kAllahAkbarMp3), + static_cast(kAllahAkbarMp3Size)); + if (!out) { + Wh_Log(L"Notification sound write incomplete"); + return false; + } + return true; +} + +void PlayNotificationSound() { + if (!EnsureNotificationSoundFile()) { + return; + } + const auto path = GetNotificationSoundPath(); + mciSendStringW(L"close prayertray_notify", nullptr, 0, nullptr); + std::wstring openCmd = + L"open \"" + path + L"\" type mpegvideo alias prayertray_notify"; + if (mciSendStringW(openCmd.c_str(), nullptr, 0, nullptr) != 0) { + openCmd = L"open \"" + path + L"\" alias prayertray_notify"; + if (mciSendStringW(openCmd.c_str(), nullptr, 0, nullptr) != 0) { + Wh_Log(L"Notification sound open failed"); + return; + } + } + // MCI volume is 0–1000; match the old app's ~12% level. + mciSendStringW(L"setaudio prayertray_notify volume to 120", nullptr, 0, + nullptr); + if (mciSendStringW(L"play prayertray_notify", nullptr, 0, nullptr) != 0) { + Wh_Log(L"Notification sound play failed"); + } +} + +void CheckNotifications() { + if (!g_settings.playPrayerNotification) return; + std::lock_guard lock(g_scheduleMutex); + if (!g_hasCurrentSchedule) return; + int dateKey = DateKey(g_currentSchedule.year, g_currentSchedule.month, + g_currentSchedule.day); + if (g_notificationActiveDateKey != dateKey) { + g_notificationActiveDateKey = dateKey; + g_playedNotificationKeys.clear(); + } + ULONGLONG nowSec = LocalNowUnixSeconds(); + const ULONGLONG leadSec = + static_cast(kNotificationLeadMinutes * 60); + auto consider = [&](const PrayerSchedule& sched) { + const int schedKey = + DateKey(sched.year, sched.month, sched.day); + for (const auto& p : sched.prayers) { + ULONGLONG t = PrayerUnixSeconds(p); + if (nowSec + leadSec < t) continue; + if (nowSec >= t) continue; + wchar_t key[64]; + swprintf(key, 64, L"%d:%d", schedKey, static_cast(p.name)); + if (g_playedNotificationKeys.insert(key).second) { + PlayNotificationSound(); + return true; + } + } + return false; + }; + if (consider(g_currentSchedule)) return; + if (g_hasNextSchedule) consider(g_nextSchedule); +} + +bool IsForegroundWindowFullscreen() { + HWND fg = GetForegroundWindow(); + if (!fg || fg == GetDesktopWindow() || fg == GetShellWindow()) { + return false; + } + + // Desktop / shell surfaces cover the monitor but are not fullscreen apps. + wchar_t className[64]{}; + if (GetClassNameW(fg, className, ARRAYSIZE(className))) { + if (_wcsicmp(className, L"Progman") == 0 || + _wcsicmp(className, L"WorkerW") == 0 || + _wcsicmp(className, L"Shell_TrayWnd") == 0 || + _wcsicmp(className, L"Shell_SecondaryTrayWnd") == 0 || + _wcsicmp(className, L"DV2ControlHost") == 0 || + _wcsicmp(className, L"ForegroundStaging") == 0 || + _wcsicmp(className, L"ApplicationManager_DesktopShellWindow") == 0) { + return false; + } + } + + // Ignore cloaked UWP shell hosts. + BOOL cloaked = FALSE; + if (SUCCEEDED(DwmGetWindowAttribute(fg, DWMWA_CLOAKED, &cloaked, sizeof(cloaked))) && + cloaked) { + return false; + } + + RECT windowRect{}; + if (!GetWindowRect(fg, &windowRect)) { + return false; + } + HMONITOR monitor = MonitorFromWindow(fg, MONITOR_DEFAULTTONEAREST); + MONITORINFO mi{sizeof(mi)}; + if (!GetMonitorInfo(monitor, &mi)) { + return false; + } + const int tol = 4; + const RECT& mr = mi.rcMonitor; + if (abs(windowRect.left - mr.left) > tol) return false; + if (abs(windowRect.top - mr.top) > tol) return false; + if (abs(windowRect.right - mr.right) > tol) return false; + if (abs(windowRect.bottom - mr.bottom) > tol) return false; + return true; +} + +bool BootstrapFromCache() { + auto locOpt = LoadLastLocation(); + if (!locOpt) { + return false; + } + + LocationInfo loc = *locOpt; + SYSTEMTIME now = GetLocalNow(); + const int method = ResolveCalculationMethod(loc); + auto today = LoadCache(now.wYear, now.wMonth, now.wDay, loc, method); + if (!today || today->prayers.empty()) { + return false; + } + + SYSTEMTIME tomorrow = now; + AddDays(tomorrow, 1); + auto nextDay = LoadCache(tomorrow.wYear, tomorrow.wMonth, tomorrow.wDay, loc, method); + + { + std::lock_guard lock(g_scheduleMutex); + g_location = loc; + g_currentSchedule = *today; + g_hasCurrentSchedule = true; + if (nextDay && !nextDay->prayers.empty()) { + g_nextSchedule = *nextDay; + g_hasNextSchedule = true; + } else { + g_hasNextSchedule = false; + } + } + Wh_Log(L"Loaded cached schedule for %s", loc.city.c_str()); + return true; +} + +void RefreshSchedulesWorker() { + if (g_refreshRunning.exchange(true)) return; + try { + LocationInfo loc; + const bool fullLocation = g_forceLocationRefresh.exchange(false); + + if (g_settings.useManualLocation) { + loc = ResolveManualLocation(); + SaveLastLocation(loc); + } else if (!fullLocation) { + if (auto last = LoadLastLocation()) { + loc = *last; + } else { + loc = ResolveLocation(); + } + } else { + loc = ResolveLocation(); + } + + SYSTEMTIME now = GetLocalNow(); + auto today = GetScheduleForDate(now.wYear, now.wMonth, now.wDay, loc); + SYSTEMTIME tomorrow = now; + AddDays(tomorrow, 1); + PrayerSchedule nextDay; + try { + nextDay = GetScheduleForDate(tomorrow.wYear, tomorrow.wMonth, tomorrow.wDay, loc); + } catch (...) { + } + { + std::lock_guard lock(g_scheduleMutex); + g_location = loc; + g_currentSchedule = today; + g_hasCurrentSchedule = !today.prayers.empty(); + g_nextSchedule = nextDay; + g_hasNextSchedule = !nextDay.prayers.empty(); + } + g_lastRefreshFailed = !g_hasCurrentSchedule; + } catch (const std::exception& ex) { + Wh_Log(L"Refresh failed: %S", ex.what()); + g_lastRefreshFailed = true; + } catch (...) { + Wh_Log(L"Refresh failed"); + g_lastRefreshFailed = true; + } + g_refreshRunning = false; + g_refreshRequested = false; + if (g_messageHwnd) { + PostMessageW(g_messageHwnd, WM_PT_UI_TICK, 0, 0); + } +} + +void RequestRefresh(bool fullLocation = false) { + if (fullLocation) { + g_forceLocationRefresh = true; + } + g_refreshRequested = true; + std::thread(RefreshSchedulesWorker).detach(); +} + +void OpenWindhawkSettings() { + ShellExecuteW(nullptr, L"open", L"windhawk:", nullptr, nullptr, SW_SHOWNORMAL); +} + +// Forward declarations +void DispatchCommand(int commandId); +void ShowFlyout(); +void HideFlyout(); +void ShowContextMenu(HWND anchor); +void ApplyEngineToBackends(); +void EnsureWin10Overlay(); +void RepositionWin10Overlay(); +void UpdateTrayIcon(); +void DestroyFlyout(); +void DestroyWin10Overlay(); +void RemoveTrayIcon(); +HWND FindCurrentProcessTaskbarWnd(); + + +void EnsureContextMenu() { + if (g_contextMenu) return; + g_contextMenu = CreatePopupMenu(); +} + +void ShowContextMenu(HWND anchor) { + EnsureContextMenu(); + while (GetMenuItemCount(g_contextMenu) > 0) { + DeleteMenu(g_contextMenu, 0, MF_BYPOSITION); + } + AppendMenuW(g_contextMenu, MF_STRING, kCmdShowFlyout, Loc(L"Tray_TodaySchedule").c_str()); + AppendMenuW(g_contextMenu, MF_STRING, kCmdRefreshLocation, Loc(L"Tray_RefreshLocation").c_str()); + AppendMenuW(g_contextMenu, MF_SEPARATOR, 0, nullptr); + AppendMenuW(g_contextMenu, MF_STRING, kCmdShowMenu + 100, Loc(L"Tray_Settings").c_str()); + POINT pt{}; + GetCursorPos(&pt); + SetForegroundWindow(g_messageHwnd ? g_messageHwnd : anchor); + const UINT cmd = TrackPopupMenu(g_contextMenu, TPM_RIGHTBUTTON | TPM_RETURNCMD, + pt.x, pt.y, 0, g_messageHwnd ? g_messageHwnd : anchor, + nullptr); + PostMessageW(g_messageHwnd ? g_messageHwnd : anchor, WM_NULL, 0, 0); + if (cmd) { + DispatchCommand(static_cast(cmd)); + } +} + +void DispatchCommand(int commandId) { + const auto now = GetTickCount64(); + if (g_lastCommandId.load() == commandId && now - g_lastCommandTick.load() < 250) { + return; + } + g_lastCommandId = commandId; + g_lastCommandTick = now; + switch (commandId) { + case kCmdShowFlyout: + ShowFlyout(); + break; + case kCmdShowMenu: + ShowContextMenu(g_win10OverlayHwnd ? g_win10OverlayHwnd : g_messageHwnd); + break; + case kCmdRefreshLocation: + RequestRefresh(true); + break; + case kCmdShowMenu + 100: + OpenWindhawkSettings(); + break; + default: + break; + } +} + + +constexpr wchar_t kFlyoutClass[] = L"PrayerTrayFlyoutWnd"; +constexpr int kFlyoutWidth = 220; +constexpr int kFlyoutRowHeight = 28; +constexpr int kFlyoutHeaderHeight = 52; +constexpr int kFlyoutOpenGraceMs = 300; + +void HideFlyout(); +void UninstallFlyoutDismissHook(); +void InstallFlyoutDismissHook(); + +LRESULT CALLBACK FlyoutMouseHookProc(int nCode, WPARAM wParam, LPARAM lParam) { + if (nCode >= 0 && g_flyoutVisible && g_flyoutHwnd && + (wParam == WM_LBUTTONDOWN || wParam == WM_RBUTTONDOWN || + wParam == WM_MBUTTONDOWN || wParam == WM_NCLBUTTONDOWN || + wParam == WM_NCRBUTTONDOWN)) { + if (GetTickCount64() >= g_flyoutSuppressDismissUntil) { + const auto* info = reinterpret_cast(lParam); + RECT rc{}; + if (GetWindowRect(g_flyoutHwnd, &rc)) { + POINT pt{info->pt.x, info->pt.y}; + if (!PtInRect(&rc, pt)) { + if (g_messageHwnd) { + PostMessageW(g_messageHwnd, WM_PT_HIDE_FLYOUT, 0, 0); + } else { + HideFlyout(); + } + } + } + } + } + return CallNextHookEx(g_flyoutMouseHook, nCode, wParam, lParam); +} + +void UninstallFlyoutDismissHook() { + if (g_flyoutMouseHook) { + UnhookWindowsHookEx(g_flyoutMouseHook); + g_flyoutMouseHook = nullptr; + } +} + +void InstallFlyoutDismissHook() { + if (g_flyoutMouseHook) { + return; + } + HMODULE module = nullptr; + GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, + reinterpret_cast(&FlyoutMouseHookProc), &module); + g_flyoutMouseHook = + SetWindowsHookExW(WH_MOUSE_LL, FlyoutMouseHookProc, module, 0); + if (!g_flyoutMouseHook) { + Wh_Log(L"Failed to install flyout dismiss mouse hook (%u)", GetLastError()); + } +} + +LRESULT CALLBACK FlyoutWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { + switch (msg) { + case WM_ACTIVATE: + if (LOWORD(wParam) == WA_INACTIVE) { + HideFlyout(); + } + return 0; + case WM_KEYDOWN: + if (wParam == VK_ESCAPE) { + HideFlyout(); + return 0; + } + break; + case WM_PAINT: { + PAINTSTRUCT ps{}; + HDC hdc = BeginPaint(hWnd, &ps); + RECT rc{}; + GetClientRect(hWnd, &rc); + bool light = IsLightTheme(); + HBRUSH bg = CreateSolidBrush(light ? RGB(252, 252, 252) : RGB(32, 32, 32)); + FillRect(hdc, &rc, bg); + DeleteObject(bg); + SetBkMode(hdc, TRANSPARENT); + SetTextColor(hdc, light ? RGB(26, 26, 26) : RGB(255, 255, 255)); + HFONT font = CreateFontW(-14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, + DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, + CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, + DEFAULT_PITCH, L"Segoe UI"); + HFONT oldFont = static_cast(SelectObject(hdc, font)); + LocationInfo loc; + { + std::lock_guard lock(g_scheduleMutex); + loc = g_location; + } + std::wstring title = Loc(L"PrayerTimes"); + std::wstring subtitle = LocationDisplayName(loc); + RECT titleRc{12, 8, rc.right - 12, 28}; + DrawTextW(hdc, title.c_str(), -1, &titleRc, DT_LEFT | DT_SINGLELINE); + RECT subRc{12, 28, rc.right - 12, 48}; + SetTextColor(hdc, light ? RGB(100, 100, 100) : RGB(180, 180, 180)); + DrawTextW(hdc, subtitle.c_str(), -1, &subRc, DT_LEFT | DT_SINGLELINE | DT_END_ELLIPSIS); + auto entries = GetTodayEntriesWithStatus(); + int y = kFlyoutHeaderHeight; + for (const auto& e : entries) { + RECT rowRc{12, y, rc.right - 12, y + kFlyoutRowHeight}; + if (e.isCurrent || e.isNext) { + HBRUSH hl = CreateSolidBrush(light ? RGB(230, 240, 255) : RGB(50, 60, 80)); + RECT fillRc{0, y, rc.right, y + kFlyoutRowHeight}; + FillRect(hdc, &fillRc, hl); + DeleteObject(hl); + } + SetTextColor(hdc, light ? RGB(26, 26, 26) : RGB(255, 255, 255)); + std::wstring name = GetPrayerName(e.name); + std::wstring time = FormatTime(e.time); + RECT nameRc{16, y + 4, rc.right / 2, y + kFlyoutRowHeight}; + RECT timeRc{rc.right / 2, y + 4, rc.right - 16, y + kFlyoutRowHeight}; + DrawTextW(hdc, name.c_str(), -1, &nameRc, DT_LEFT | DT_SINGLELINE); + DrawTextW(hdc, time.c_str(), -1, &timeRc, DT_RIGHT | DT_SINGLELINE); + y += kFlyoutRowHeight; + } + SelectObject(hdc, oldFont); + DeleteObject(font); + EndPaint(hWnd, &ps); + return 0; + } + } + return DefWindowProcW(hWnd, msg, wParam, lParam); +} + +void EnsureFlyoutWindow() { + if (g_flyoutHwnd) return; + static bool registered = false; + if (!registered) { + WNDCLASSW wc{}; + wc.lpfnWndProc = FlyoutWndProc; + wc.hInstance = GetModuleHandleW(nullptr); + wc.lpszClassName = kFlyoutClass; + wc.hbrBackground = nullptr; + RegisterClassW(&wc); + registered = true; + } + g_flyoutHwnd = CreateWindowExW( + WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE, kFlyoutClass, L"", + WS_POPUP | WS_BORDER, 0, 0, kFlyoutWidth, + kFlyoutHeaderHeight + kFlyoutRowHeight * 5 + 8, g_messageHwnd, nullptr, + GetModuleHandleW(nullptr), nullptr); +} + +bool TryGetSlotAnchor(RECT& anchor) { + const int slotW = 60, slotH = 40, gap = 4; + HWND shell = FindCurrentProcessTaskbarWnd(); + if (!shell) return false; + HWND trayNotify = FindWindowExW(shell, nullptr, L"TrayNotifyWnd", nullptr); + RECT notifyRect{}; + if (trayNotify && GetWindowRect(trayNotify, ¬ifyRect)) { + HWND clock = FindWindowExW(trayNotify, nullptr, L"TrayClockWClass", nullptr); + if (!clock) clock = FindWindowExW(trayNotify, nullptr, L"ClockButton", nullptr); + int clockLeft = notifyRect.right - 26 - 60; + if (clock && GetWindowRect(clock, &anchor)) { + clockLeft = anchor.left; + } + anchor.left = clockLeft - gap - slotW + 12; + anchor.top = notifyRect.top + (notifyRect.bottom - notifyRect.top - slotH) / 2; + anchor.right = anchor.left + slotW; + anchor.bottom = anchor.top + slotH; + return true; + } + return false; +} + +void ShowFlyout() { + EnsureFlyoutWindow(); + if (!g_flyoutHwnd) return; + RECT anchor{}; + if (!TryGetSlotAnchor(anchor)) { + anchor = {GetSystemMetrics(SM_CXSCREEN) - 200, GetSystemMetrics(SM_CYSCREEN) - 48, 0, 0}; + anchor.right = anchor.left + 60; + anchor.bottom = anchor.top + 40; + } + int height = kFlyoutHeaderHeight + kFlyoutRowHeight * 5 + 8; + int left = anchor.right - kFlyoutWidth; + int top = anchor.top - height - 8; + HMONITOR mon = MonitorFromRect(&anchor, MONITOR_DEFAULTTONEAREST); + MONITORINFO mi{sizeof(mi)}; + GetMonitorInfo(mon, &mi); + if (left < mi.rcWork.left + 8) left = mi.rcWork.left + 8; + if (top < mi.rcWork.top + 8) top = mi.rcWork.top + 8; + SetWindowPos(g_flyoutHwnd, HWND_TOPMOST, left, top, kFlyoutWidth, height, + SWP_SHOWWINDOW | SWP_NOACTIVATE); + InvalidateRect(g_flyoutHwnd, nullptr, TRUE); + g_flyoutVisible = true; + g_flyoutSuppressDismissUntil = GetTickCount64() + kFlyoutOpenGraceMs; + InstallFlyoutDismissHook(); +} + +void HideFlyout() { + if (g_flyoutHwnd && g_flyoutVisible) { + ShowWindow(g_flyoutHwnd, SW_HIDE); + g_flyoutVisible = false; + } + UninstallFlyoutDismissHook(); +} + +void DestroyFlyout() { + HideFlyout(); + if (g_flyoutHwnd) { + DestroyWindow(g_flyoutHwnd); + g_flyoutHwnd = nullptr; + } +} + + +void UpdateTrayIcon() { + if (!g_messageHwnd) return; + if (g_settings.showNotificationIcon) { + if (!g_trayIconAdded) { + ZeroMemory(&g_trayIcon, sizeof(g_trayIcon)); + g_trayIcon.cbSize = sizeof(g_trayIcon); + g_trayIcon.hWnd = g_messageHwnd; + g_trayIcon.uID = 1; + g_trayIcon.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP; + g_trayIcon.uCallbackMessage = WM_APP + 10; + g_trayIcon.hIcon = LoadIconW(nullptr, IDI_APPLICATION); + wcscpy_s(g_trayIcon.szTip, L"PrayerTray"); + Shell_NotifyIconW(NIM_ADD, &g_trayIcon); + g_trayIconAdded = true; + } + } else { + RemoveTrayIcon(); + } +} + +void RemoveTrayIcon() { + if (g_trayIconAdded) { + Shell_NotifyIconW(NIM_DELETE, &g_trayIcon); + g_trayIconAdded = false; + } +} + + +constexpr wchar_t kOverlayClass[] = L"PrayerTrayOverlayWnd"; +std::wstring g_win10Top; +std::wstring g_win10Bottom; +bool g_win10Visible = false; +COLORREF g_win10TextColor = RGB(255, 255, 255); + +LRESULT CALLBACK Win10OverlayProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { + switch (msg) { + case WM_LBUTTONUP: + DispatchCommand(kCmdShowFlyout); + return 0; + case WM_RBUTTONUP: + DispatchCommand(kCmdShowMenu); + return 0; + case WM_PAINT: { + PAINTSTRUCT ps{}; + HDC hdc = BeginPaint(hWnd, &ps); + RECT rc{}; + GetClientRect(hWnd, &rc); + SetBkMode(hdc, TRANSPARENT); + SetTextColor(hdc, g_win10TextColor); + HFONT font = CreateFontW(-12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, + DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, + CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, + DEFAULT_PITCH, L"Segoe UI"); + HFONT old = static_cast(SelectObject(hdc, font)); + if (g_win10Visible) { + RECT topRc = rc; + topRc.bottom = (rc.top + rc.bottom) / 2; + RECT botRc = rc; + botRc.top = topRc.bottom; + DrawTextW(hdc, g_win10Top.c_str(), -1, &topRc, + DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX); + DrawTextW(hdc, g_win10Bottom.c_str(), -1, &botRc, + DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX); + } + SelectObject(hdc, old); + DeleteObject(font); + EndPaint(hWnd, &ps); + return 0; + } + } + return DefWindowProcW(hWnd, msg, wParam, lParam); +} + +void EnsureWin10Overlay() { + if (g_backend.load() != TaskbarBackend::Win10Overlay) return; + static bool registered = false; + if (!registered) { + WNDCLASSW wc{}; + wc.lpfnWndProc = Win10OverlayProc; + wc.hInstance = GetModuleHandleW(nullptr); + wc.lpszClassName = kOverlayClass; + wc.hCursor = LoadCursorW(nullptr, IDC_HAND); + RegisterClassW(&wc); + registered = true; + } + HWND shell = FindCurrentProcessTaskbarWnd(); + if (!shell) return; + if (!g_win10OverlayHwnd) { + g_win10OverlayHwnd = CreateWindowExW( + WS_EX_TOOLWINDOW, kOverlayClass, L"", WS_CHILD | WS_VISIBLE, 0, 0, 60, + 40, shell, nullptr, GetModuleHandleW(nullptr), nullptr); + } + RepositionWin10Overlay(); +} + +void RepositionWin10Overlay() { + if (!g_win10OverlayHwnd) return; + HWND shell = FindCurrentProcessTaskbarWnd(); + if (!shell) return; + const int w = 60, h = 40, gap = 4; + int cx = 0, cy = 0; + HWND trayNotify = FindWindowExW(shell, nullptr, L"TrayNotifyWnd", nullptr); + RECT notifyRect{}; + if (trayNotify && GetWindowRect(trayNotify, ¬ifyRect)) { + HWND clock = FindWindowExW(trayNotify, nullptr, L"TrayClockWClass", nullptr); + if (!clock) clock = FindWindowExW(trayNotify, nullptr, L"ClockButton", nullptr); + int clockLeft = notifyRect.right - 26 - 60; + if (clock) { + RECT cr{}; + GetWindowRect(clock, &cr); + clockLeft = cr.left; + } + POINT pt{clockLeft - gap - w + 12, + notifyRect.top + (notifyRect.bottom - notifyRect.top - h) / 2}; + ScreenToClient(shell, &pt); + cx = pt.x; + cy = pt.y; + } + const bool show = g_win10Visible; + if (g_hasOverlayPlacement && g_lastOverlayShown == show && + g_lastOverlayX == cx && g_lastOverlayY == cy && g_lastOverlayW == w && + g_lastOverlayH == h) { + return; + } + ShowWindow(g_win10OverlayHwnd, show ? SW_SHOW : SW_HIDE); + SetWindowPos(g_win10OverlayHwnd, HWND_TOP, cx, cy, w, h, SWP_NOACTIVATE); + g_hasOverlayPlacement = true; + g_lastOverlayShown = show; + g_lastOverlayX = cx; + g_lastOverlayY = cy; + g_lastOverlayW = w; + g_lastOverlayH = h; +} + +void DestroyWin10Overlay() { + if (g_win10OverlayHwnd) { + DestroyWindow(g_win10OverlayHwnd); + g_win10OverlayHwnd = nullptr; + } + g_hasOverlayPlacement = false; +} + +void ApplyWin10Content(const DisplayContent& content) { + const bool visibilityChanged = g_win10Visible != content.visible; + g_win10Top = content.top; + g_win10Bottom = content.bottom; + g_win10Visible = content.visible; + if (content.color == L"1A1A1A") g_win10TextColor = RGB(26, 26, 26); + else g_win10TextColor = RGB(255, 255, 255); + EnsureWin10Overlay(); + if (g_win10OverlayHwnd) { + InvalidateRect(g_win10OverlayHwnd, nullptr, FALSE); + if (visibilityChanged || !g_hasOverlayPlacement) { + RepositionWin10Overlay(); + } + } +} + + +Media::SolidColorBrush Brush(uint8_t alpha, uint8_t red, uint8_t green, + uint8_t blue) { + return Media::SolidColorBrush({alpha, red, green, blue}); +} + +winrt::Windows::UI::Color ParseColor(const std::wstring& color) { + std::wstring hex = color; + if (hex.starts_with(L"#")) hex = hex.substr(1); + if (hex.size() != 6) return winrt::Windows::UI::Color{255, 255, 255, 255}; + auto parseByte = [&hex](size_t offset) -> uint8_t { + wchar_t buf[3] = {hex[offset], hex[offset + 1], 0}; + return static_cast(wcstoul(buf, nullptr, 16)); + }; + return winrt::Windows::UI::Color{255, parseByte(0), parseByte(2), parseByte(4)}; +} + +FrameworkElement FindChildByName(FrameworkElement element, PCWSTR name) { + int n = Media::VisualTreeHelper::GetChildrenCount(element); + for (int i = 0; i < n; i++) { + auto child = Media::VisualTreeHelper::GetChild(element, i).try_as(); + if (!child) continue; + if (child.Name() == name) return child; + if (auto match = FindChildByName(child, name)) return match; + } + return nullptr; +} + +Controls::TextBlock FindTextBlockByName(FrameworkElement element, PCWSTR name) { + if (auto named = element.FindName(name).try_as()) return named; + return FindChildByName(element, name).try_as(); +} + +FrameworkElement FindChildByClassName(FrameworkElement element, PCWSTR className) { + if (winrt::get_class_name(element) == className) return element; + int n = Media::VisualTreeHelper::GetChildrenCount(element); + for (int i = 0; i < n; i++) { + auto child = Media::VisualTreeHelper::GetChild(element, i).try_as(); + if (!child) continue; + if (auto match = FindChildByClassName(child, className)) return match; + } + return nullptr; +} + +FrameworkElement FindMainStackIconStackPanel(FrameworkElement mainStack) { + FrameworkElement child = mainStack; + if ((child = FindChildByName(child, L"Content")) && + (child = FindChildByName(child, L"IconStack")) && + (child = FindChildByClassName(child, L"Windows.UI.Xaml.Controls.ItemsPresenter")) && + (child = FindChildByClassName(child, L"Windows.UI.Xaml.Controls.StackPanel"))) { + return child; + } + return nullptr; +} + +FrameworkElement FindDirectChildByName(Controls::Panel panel, PCWSTR name) { + for (uint32_t i = 0; i < panel.Children().Size(); i++) { + auto child = panel.Children().GetAt(i).try_as(); + if (child && child.Name() == name) return child; + } + return nullptr; +} + +Controls::Grid FindTrayGridFromAnchor(FrameworkElement root) { + FrameworkElement anchor = FindChildByName(root, L"NotificationCenterButton"); + if (!anchor) anchor = FindChildByName(root, L"ControlCenterButton"); + if (!anchor) return nullptr; + DependencyObject current = anchor; + while (current) { + current = Media::VisualTreeHelper::GetParent(current); + if (!current) break; + if (auto grid = current.try_as()) { + if (FindDirectChildByName(grid, L"NotificationCenterButton") || + FindDirectChildByName(grid, L"ControlCenterButton")) { + return grid; + } + } + } + return nullptr; +} + +FrameworkElement ResolveMainStack(FrameworkElement root) { + if (root.Name() == L"MainStack" || winrt::get_class_name(root) == L"SystemTray.Stack") { + return root; + } + return FindChildByName(root, L"MainStack"); +} + +bool IsSlotRootAlive() { + if (!g_slotInjected) return false; + try { + return g_slotRoot && winrt::get_abi(g_slotRoot) != nullptr; + } catch (...) { + return false; + } +} + +void ApplySlotButtonVisualState() { + auto button = g_slotButton; + if (!button) return; + uint8_t alpha = 0; + if (g_slotPointerPressed.load()) alpha = 0x3A; + else if (g_slotPointerOver.load()) alpha = 0x26; + button.Background(Brush(alpha, 255, 255, 255)); +} + +void ResetSlotButtonVisualState() { + g_slotPointerOver = false; + g_slotPointerPressed = false; + ApplySlotButtonVisualState(); +} + +void ApplyWin11SlotContent(const DisplayContent& content) { + auto top = g_topTextBlock; + auto bottom = g_bottomTextBlock; + auto root = g_slotRoot; + if (!top || !bottom || !root) { + g_slotInjected = false; + return; + } + const bool show = content.visible && (!content.top.empty() || !content.bottom.empty()); + const bool changed = !g_hasAppliedContent || g_lastAppliedVisible != show || + g_lastAppliedTop != content.top || + g_lastAppliedBottom != content.bottom || + g_lastAppliedColor != content.color; + // Prefer opacity over Collapsed so tray columns do not reflow/flicker. + if (!g_hasAppliedContent || g_lastAppliedVisible != show) { + root.Visibility(Visibility::Visible); + root.Opacity(show ? 1.0 : 0.0); + root.IsHitTestVisible(show); + } + if (!show) { + if (changed) { + g_hasAppliedContent = true; + g_lastAppliedVisible = false; + g_lastAppliedTop = content.top; + g_lastAppliedBottom = content.bottom; + g_lastAppliedColor = content.color; + } + return; + } + if (!changed) return; + const auto brush = Media::SolidColorBrush(ParseColor(content.color)); + top.Text(content.top); + top.FlowDirection(FlowDirection::LeftToRight); + top.Foreground(brush); + bottom.Text(content.bottom); + bottom.Foreground(brush); + g_hasAppliedContent = true; + g_lastAppliedVisible = true; + g_lastAppliedTop = content.top; + g_lastAppliedBottom = content.bottom; + g_lastAppliedColor = content.color; +} + +void AttachSlotInteractions(FrameworkElement slotRoot) { + auto button = slotRoot.try_as(); + if (!button) return; + if (auto existing = g_slotButton) { + if (winrt::get_abi(existing) == winrt::get_abi(button)) return; + } + g_slotButton = button; + ResetSlotButtonVisualState(); + button.PointerEntered([](auto&, Input::PointerRoutedEventArgs const&) { + g_slotPointerOver = true; + ApplySlotButtonVisualState(); + }); + button.PointerExited([](auto&, Input::PointerRoutedEventArgs const&) { + g_slotPointerOver = false; + g_slotPointerPressed = false; + ApplySlotButtonVisualState(); + }); + button.Click([](auto&, RoutedEventArgs const&) { DispatchCommand(kCmdShowFlyout); }); + button.RightTapped([](auto&, Input::RightTappedRoutedEventArgs const& args) { + DispatchCommand(kCmdShowMenu); + args.Handled(true); + }); + button.PointerPressed([](winrt::Windows::Foundation::IInspectable const& sender, + Input::PointerRoutedEventArgs const& args) { + auto element = sender.try_as(); + if (!element) return; + auto props = args.GetCurrentPoint(element).Properties(); + if (props.IsRightButtonPressed() || props.IsLeftButtonPressed()) { + g_slotPointerOver = true; + g_slotPointerPressed = true; + ApplySlotButtonVisualState(); + if (props.IsRightButtonPressed()) args.Handled(true); + } + }); + button.PointerReleased([](auto&, Input::PointerRoutedEventArgs const&) { + g_slotPointerPressed = false; + ApplySlotButtonVisualState(); + }); +} + +void RemovePrayerTraySlotFromGrid(Controls::Grid trayGrid) { + auto children = trayGrid.Children(); + int slotColumn = -1; + for (uint32_t i = 0; i < children.Size(); i++) { + auto child = children.GetAt(i).try_as(); + if (child && child.Name() == L"PrayerTraySlotRoot") { + slotColumn = Controls::Grid::GetColumn(child); + children.RemoveAt(i); + break; + } + } + if (slotColumn >= 0 && slotColumn < static_cast(trayGrid.ColumnDefinitions().Size())) { + for (uint32_t i = 0; i < children.Size(); i++) { + auto child = children.GetAt(i).try_as(); + if (!child) continue; + int col = Controls::Grid::GetColumn(child); + if (col > slotColumn) Controls::Grid::SetColumn(child, col - 1); + } + trayGrid.ColumnDefinitions().RemoveAt(slotColumn); + } + g_slotRoot = nullptr; + g_slotButton = nullptr; + g_topTextBlock = nullptr; + g_bottomTextBlock = nullptr; + g_slotParentGrid = nullptr; + g_slotInjected = false; + g_hasAppliedContent = false; +} + +int ResolveTraySlotColumn(Controls::Grid trayGrid) { + if (auto clock = FindDirectChildByName(trayGrid, L"NotificationCenterButton")) { + return Controls::Grid::GetColumn(clock); + } + if (auto cc = FindDirectChildByName(trayGrid, L"ControlCenterButton")) { + return Controls::Grid::GetColumn(cc) + 1; + } + return -1; +} + +bool EnsurePrayerTraySlotInTrayGrid(Controls::Grid trayGrid) { + if (IsSlotRootAlive() && g_slotParentGrid && + winrt::get_abi(g_slotParentGrid) == winrt::get_abi(trayGrid)) { + AttachSlotInteractions(g_slotRoot); + return true; + } + while (FindDirectChildByName(trayGrid, L"PrayerTraySlotRoot")) { + RemovePrayerTraySlotFromGrid(trayGrid); + } + int slotColumn = ResolveTraySlotColumn(trayGrid); + if (slotColumn < 0) return false; + slotColumn = std::clamp(slotColumn, 0, static_cast(trayGrid.ColumnDefinitions().Size())); + Controls::Button slotButton; + slotButton.Name(L"PrayerTraySlotRoot"); + slotButton.Background(Brush(0, 255, 255, 255)); + slotButton.BorderBrush(Brush(0, 255, 255, 255)); + slotButton.BorderThickness({0, 0, 0, 0}); + slotButton.Height(40); + slotButton.MinWidth(52); + slotButton.Padding({7, 0, 7, 0}); + slotButton.Margin({2, 0, 2, 0}); + slotButton.VerticalAlignment(VerticalAlignment::Center); + slotButton.HorizontalAlignment(HorizontalAlignment::Center); + Controls::StackPanel slotStack; + slotStack.Orientation(Controls::Orientation::Vertical); + slotStack.IsHitTestVisible(false); + Controls::TextBlock topText; + topText.Name(L"PrayerTrayTop"); + topText.FontFamily(Media::FontFamily(L"Segoe UI Variable Text")); + topText.FontSize(11.5); + topText.FlowDirection(FlowDirection::LeftToRight); + topText.TextAlignment(TextAlignment::Center); + Controls::TextBlock bottomText; + bottomText.Name(L"PrayerTrayBottom"); + bottomText.FontFamily(Media::FontFamily(L"Segoe UI Variable Text")); + bottomText.FontSize(11.5); + bottomText.TextAlignment(TextAlignment::Center); + slotStack.Children().Append(topText); + slotStack.Children().Append(bottomText); + slotButton.Content(slotStack); + FrameworkElement slotElement = slotButton; + Controls::ColumnDefinition column; + column.Width({1.0, GridUnitType::Auto}); + if (slotColumn >= static_cast(trayGrid.ColumnDefinitions().Size())) { + trayGrid.ColumnDefinitions().Append(column); + } else { + trayGrid.ColumnDefinitions().InsertAt(slotColumn, column); + for (uint32_t i = 0; i < trayGrid.Children().Size(); i++) { + auto child = trayGrid.Children().GetAt(i).try_as(); + if (!child) continue; + int col = Controls::Grid::GetColumn(child); + if (col >= slotColumn) Controls::Grid::SetColumn(child, col + 1); + } + } + Controls::Grid::SetColumn(slotElement, slotColumn); + trayGrid.Children().Append(slotElement); + g_slotRoot = slotElement; + g_topTextBlock = topText; + g_bottomTextBlock = bottomText; + g_slotParentGrid = trayGrid; + g_slotInjected = true; + g_hasAppliedContent = false; + g_injectRetryMs = 400; + AttachSlotInteractions(slotElement); + return true; +} + +bool EnsurePrayerTraySlot(FrameworkElement mainStack) { + if (IsSlotRootAlive()) { + AttachSlotInteractions(g_slotRoot); + return true; + } + auto stackPanelElement = FindMainStackIconStackPanel(mainStack); + if (!stackPanelElement) return false; + auto stackPanel = stackPanelElement.try_as(); + if (!stackPanel) return false; + PCWSTR xaml = LR"()"; + auto slotButton = Markup::XamlReader::Load(xaml).try_as(); + if (!slotButton) return false; + stackPanel.Children().Append(slotButton); + g_slotRoot = slotButton; + g_topTextBlock = FindTextBlockByName(slotButton, L"PrayerTrayTop"); + g_bottomTextBlock = FindTextBlockByName(slotButton, L"PrayerTrayBottom"); + g_slotInjected = true; + g_hasAppliedContent = false; + g_injectRetryMs = 400; + AttachSlotInteractions(slotButton); + return true; +} + +void TrackObservedElement(FrameworkElement element) { + if (!element) return; + for (auto it = g_observedElements.begin(); it != g_observedElements.end();) { + if (!it->get()) it = g_observedElements.erase(it); + else if (winrt::get_abi(it->get()) == winrt::get_abi(element)) return; + else ++it; + } + g_observedElements.emplace_back(element); + while (g_observedElements.size() > 64) g_observedElements.pop_front(); +} + +bool ApplyWin11Style(XamlRoot xamlRoot, const DisplayContent& content) { + FrameworkElement child = xamlRoot.Content().try_as(); + if (!child) return false; + if (IsSlotRootAlive()) { + ApplyWin11SlotContent(content); + return true; + } + if (auto frameGrid = FindChildByName(child, L"SystemTrayFrameGrid")) { + if (auto trayGrid = frameGrid.try_as()) { + if (EnsurePrayerTraySlotInTrayGrid(trayGrid)) { + ApplyWin11SlotContent(content); + return true; + } + } + } + if (auto trayGrid = FindTrayGridFromAnchor(child)) { + if (EnsurePrayerTraySlotInTrayGrid(trayGrid)) { + ApplyWin11SlotContent(content); + return true; + } + } + if (auto mainStack = ResolveMainStack(child)) { + if (EnsurePrayerTraySlot(mainStack)) { + ApplyWin11SlotContent(content); + return true; + } + } + return false; +} + +using RunFromWindowThreadProc_t = void(WINAPI*)(void*); + +bool RunFromWindowThread(HWND hWnd, RunFromWindowThreadProc_t proc, void* param) { + static const UINT msg = RegisterWindowMessage(L"Windhawk_RunFromWindowThread_" WH_MOD_ID); + struct Param { RunFromWindowThreadProc_t proc; void* param; }; + DWORD tid = GetWindowThreadProcessId(hWnd, nullptr); + if (!tid) return false; + if (tid == GetCurrentThreadId()) { + proc(param); + return true; + } + HHOOK hook = SetWindowsHookExW( + WH_CALLWNDPROC, + [](int nCode, WPARAM wParam, LPARAM lParam) -> LRESULT { + if (nCode == HC_ACTION) { + const CWPSTRUCT* cwp = reinterpret_cast(lParam); + static const UINT m = RegisterWindowMessage(L"Windhawk_RunFromWindowThread_" WH_MOD_ID); + if (cwp->message == m) { + auto* p = reinterpret_cast(cwp->lParam); + p->proc(p->param); + } + } + return CallNextHookEx(nullptr, nCode, wParam, lParam); + }, + nullptr, tid); + if (!hook) return false; + Param p{proc, param}; + SendMessageW(hWnd, msg, 0, reinterpret_cast(&p)); + UnhookWindowsHookEx(hook); + return true; +} + +HWND FindCurrentProcessTaskbarWnd() { + HWND result = nullptr; + EnumWindows( + [](HWND hWnd, LPARAM lParam) -> BOOL { + DWORD pid; + WCHAR cls[32]; + if (GetWindowThreadProcessId(hWnd, &pid) && pid == GetCurrentProcessId() && + GetClassNameW(hWnd, cls, 32) && _wcsicmp(cls, L"Shell_TrayWnd") == 0) { + *reinterpret_cast(lParam) = hWnd; + return FALSE; + } + return TRUE; + }, + reinterpret_cast(&result)); + return result; +} + +struct SlotApplyParam { DisplayContent content; }; + +void ApplyWin11FromThread(SlotApplyParam* param) { + DisplayContent content = param ? param->content : FormatTaskbarDisplay(); + if (IsSlotRootAlive()) { + ApplyWin11SlotContent(content); + g_injectRetryMs = 400; + return; + } + bool injected = false; + for (auto it = g_observedElements.begin(); it != g_observedElements.end();) { + auto element = it->get(); + if (!element) { + it = g_observedElements.erase(it); + continue; + } + try { + if (auto xr = element.XamlRoot()) { + if (ApplyWin11Style(xr, content)) { + injected = true; + break; + } + } + } catch (...) { + } + ++it; + } + if (IsSlotRootAlive()) { + ApplyWin11SlotContent(content); + g_injectRetryMs = 400; + return; + } + if (!injected) { + const int next = std::min(3000, std::max(400, g_injectRetryMs.load() * 2)); + g_injectRetryMs = next; + } +} + +void TryApplyWin11Slot() { + if (g_backend.load() != TaskbarBackend::Win11Xaml) return; + ++g_applySlotAttempts; + HWND taskbar = FindCurrentProcessTaskbarWnd(); + if (!taskbar) return; + DisplayContent content = FormatTaskbarDisplay(); + SlotApplyParam param{content}; + RunFromWindowThread(taskbar, [](void* p) { ApplyWin11FromThread(static_cast(p)); }, ¶m); +} + +void ApplyEngineToBackends() { + if (g_backend.load() == TaskbarBackend::Win11Xaml) { + TryApplyWin11Slot(); + } else { + ApplyWin10Content(FormatTaskbarDisplay()); + } +} + +void* CTaskBand_ITaskListWndSite_vftable; +using CTaskBand_GetTaskbarHost_t = void*(WINAPI*)(void*, void**); +CTaskBand_GetTaskbarHost_t CTaskBand_GetTaskbarHost_Original; +void* TaskbarHost_FrameHeight_Original; +using std__Ref_count_base__Decref_t = void(WINAPI*)(void*); +std__Ref_count_base__Decref_t std__Ref_count_base__Decref_Original; + +using IconView_IconView_t = void*(WINAPI*)(void*); +IconView_IconView_t IconView_IconView_Original; +using SystemTrayFrame_OnApplyTemplate_t = void(WINAPI*)(void*); +SystemTrayFrame_OnApplyTemplate_t SystemTrayFrame_OnApplyTemplate_Original; +using SystemTrayFrame_MeasureOverride_t = + winrt::Windows::Foundation::Size(WINAPI*)(void*, winrt::Windows::Foundation::Size const&); +SystemTrayFrame_MeasureOverride_t SystemTrayFrame_MeasureOverride_Original; +using LoadLibraryExW_t = decltype(&LoadLibraryExW); +LoadLibraryExW_t LoadLibraryExW_Original; + +FrameworkElement TryGetFrameworkElementFromImplementation(void* pThis) { + if (!pThis) return nullptr; + FrameworkElement element = nullptr; + try { + auto object = reinterpret_cast(pThis)[1]; + if (object) { + object->QueryInterface(winrt::guid_of(), winrt::put_abi(element)); + } + } catch (...) { + } + return element; +} + +void TryApplySlotFromElement(FrameworkElement element) { + if (g_unloading || !element || g_backend.load() != TaskbarBackend::Win11Xaml) return; + try { + TrackObservedElement(element); + if (IsSlotRootAlive()) { + ApplyWin11SlotContent(FormatTaskbarDisplay()); + return; + } + if (auto xr = element.XamlRoot()) ApplyWin11Style(xr, FormatTaskbarDisplay()); + } catch (...) { + } +} + +void* WINAPI IconView_IconView_Hook(void* pThis) { + void* ret = IconView_IconView_Original(pThis); + if (!g_unloading) TryApplySlotFromElement(TryGetFrameworkElementFromImplementation(pThis)); + return ret; +} + +void WINAPI SystemTrayFrame_OnApplyTemplate_Hook(void* pThis) { + SystemTrayFrame_OnApplyTemplate_Original(pThis); + if (!g_unloading) TryApplySlotFromElement(TryGetFrameworkElementFromImplementation(pThis)); +} + +winrt::Windows::Foundation::Size WINAPI SystemTrayFrame_MeasureOverride_Hook( + void* pThis, winrt::Windows::Foundation::Size const& availableSize) { + auto result = SystemTrayFrame_MeasureOverride_Original(pThis, availableSize); + // Measure runs constantly during tray layout. Never touch an already-injected + // slot here, and debounce inject attempts so we don't fight layout. + if (g_unloading || IsSlotRootAlive()) { + return result; + } + const ULONGLONG now = GetTickCount64(); + const ULONGLONG last = g_lastMeasureInjectAttemptMs.load(); + if (now - last < 1000) { + return result; + } + g_lastMeasureInjectAttemptMs = now; + TryApplySlotFromElement(TryGetFrameworkElementFromImplementation(pThis)); + return result; +} + +HMODULE GetTaskbarViewModuleHandle() { + HMODULE m = GetModuleHandleW(L"Taskbar.View.dll"); + if (!m) m = GetModuleHandleW(L"ExplorerExtensions.dll"); + return m; +} + +bool HookTaskbarViewDllSymbols(HMODULE module) { + WindhawkUtils::SYMBOL_HOOK hooks[] = { + {{LR"(public: __cdecl winrt::SystemTray::implementation::IconView::IconView(void))"}, + &IconView_IconView_Original, IconView_IconView_Hook, true}, + {{LR"(protected: virtual void __cdecl winrt::SystemTray::implementation::SystemTrayFrame::OnApplyTemplate(void))", + LR"(public: virtual void __cdecl winrt::SystemTray::implementation::SystemTrayFrame::OnApplyTemplate(void))"}, + &SystemTrayFrame_OnApplyTemplate_Original, SystemTrayFrame_OnApplyTemplate_Hook, true}, + {{LR"(protected: virtual struct winrt::Windows::Foundation::Size __cdecl winrt::SystemTray::implementation::SystemTrayFrame::MeasureOverride(struct winrt::Windows::Foundation::Size const &))", + LR"(public: virtual struct winrt::Windows::Foundation::Size __cdecl winrt::SystemTray::implementation::SystemTrayFrame::MeasureOverride(struct winrt::Windows::Foundation::Size const &))"}, + &SystemTrayFrame_MeasureOverride_Original, SystemTrayFrame_MeasureOverride_Hook, true}, + }; + return HookSymbols(module, hooks, ARRAYSIZE(hooks)); +} + +void HandleLoadedModuleIfTaskbarView(HMODULE module, LPCWSTR name) { + if (!g_taskbarViewDllLoaded && GetTaskbarViewModuleHandle() == module && + !g_taskbarViewDllLoaded.exchange(true)) { + Wh_Log(L"Loaded %s", name); + if (HookTaskbarViewDllSymbols(module)) Wh_ApplyHookOperations(); + } +} + +HMODULE WINAPI LoadLibraryExW_Hook(LPCWSTR name, HANDLE file, DWORD flags) { + HMODULE module = LoadLibraryExW_Original(name, file, flags); + if (module) HandleLoadedModuleIfTaskbarView(module, name); + return module; +} + +bool HookTaskbarDllSymbols() { + HMODULE module = LoadLibraryExW(L"taskbar.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32); + if (!module) return false; + WindhawkUtils::SYMBOL_HOOK hooks[] = { + {{LR"(const CTaskBand::`vftable'{for `ITaskListWndSite'})"}, &CTaskBand_ITaskListWndSite_vftable}, + {{LR"(public: virtual class std::shared_ptr __cdecl CTaskBand::GetTaskbarHost(void)const )"}, + &CTaskBand_GetTaskbarHost_Original}, + {{LR"(public: int __cdecl TaskbarHost::FrameHeight(void)const )"}, &TaskbarHost_FrameHeight_Original}, + {{LR"(public: void __cdecl std::_Ref_count_base::_Decref(void))"}, &std__Ref_count_base__Decref_Original}, + }; + return HookSymbols(module, hooks, ARRAYSIZE(hooks)); +} + +void SelectBackend() { + bool win11 = DetectWin11(); + g_isWin11 = win11; + if (win11 && !g_settings.oldTaskbarOnWin11) { + g_backend = TaskbarBackend::Win11Xaml; + } else { + g_backend = TaskbarBackend::Win10Overlay; + } + Wh_Log(L"Backend: %s", g_backend.load() == TaskbarBackend::Win11Xaml ? L"Win11" : L"Win10"); +} + + +void RestartUiTimer() { + const int intervalMs = g_uiTimerIntervalMs.load(); + if (g_uiTimer && g_lastUiTimerIntervalMs == intervalMs) { + return; + } + g_uiTimer = SetTimer(g_messageHwnd, 1, intervalMs, nullptr); + g_lastUiTimerIntervalMs = intervalMs; +} + +VOID CALLBACK FullscreenTimerProc(HWND, UINT, UINT_PTR, DWORD) { + bool fs = IsForegroundWindowFullscreen(); + if (fs != g_isFullscreen.load()) { + g_isFullscreen = fs; + ApplyEngineToBackends(); + } +} + +LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { + switch (msg) { + case WM_TIMER: + if (wParam == 1) { + ApplyEngineToBackends(); + CheckNotifications(); + RestartUiTimer(); + } else if (wParam == 2) { + RepositionWin10Overlay(); + } + return 0; + case WM_PT_UI_TICK: + case WM_PT_REFRESH: + ApplyEngineToBackends(); + return 0; + case WM_PT_HIDE_FLYOUT: + HideFlyout(); + return 0; + case WM_APP + 10: + switch (LOWORD(lParam)) { + case WM_LBUTTONUP: + DispatchCommand(kCmdShowFlyout); + break; + case WM_RBUTTONUP: + DispatchCommand(kCmdShowMenu); + break; + } + return 0; + case WM_COMMAND: + DispatchCommand(static_cast(LOWORD(wParam))); + return 0; + case WM_DESTROY: + return 0; + } + return DefWindowProcW(hWnd, msg, wParam, lParam); +} + +void EnsureMessageWindow() { + if (g_messageHwnd) return; + static bool reg = false; + if (!reg) { + WNDCLASSW wc{}; + wc.lpfnWndProc = MessageWndProc; + wc.hInstance = GetModuleHandleW(nullptr); + wc.lpszClassName = L"PrayerTrayMessageWnd"; + RegisterClassW(&wc); + reg = true; + } + g_messageHwnd = CreateWindowExW(0, L"PrayerTrayMessageWnd", L"PrayerTray", 0, 0, 0, 0, 0, + HWND_MESSAGE, nullptr, GetModuleHandleW(nullptr), nullptr); +} + +void StartTimers() { + EnsureMessageWindow(); + RestartUiTimer(); + g_repositionTimer = SetTimer(g_messageHwnd, 2, 2000, nullptr); + g_fullscreenTimer = SetTimer(nullptr, 3, 500, FullscreenTimerProc); +} + +void StopTimers() { + if (g_messageHwnd) { + KillTimer(g_messageHwnd, 1); + KillTimer(g_messageHwnd, 2); + } + g_uiTimer = 0; + g_repositionTimer = 0; + g_lastUiTimerIntervalMs = -1; + if (g_fullscreenTimer) { + KillTimer(nullptr, g_fullscreenTimer); + g_fullscreenTimer = 0; + } +} + +void ShutdownUi() { + StopTimers(); + HideFlyout(); + DestroyFlyout(); + DestroyWin10Overlay(); + RemoveTrayIcon(); + if (g_contextMenu) { + DestroyMenu(g_contextMenu); + g_contextMenu = nullptr; + } + if (g_messageHwnd) { + DestroyWindow(g_messageHwnd); + g_messageHwnd = nullptr; + } + g_loadedRevokers.clear(); + g_observedElements.clear(); + if (auto root = g_slotRoot) { + try { + root.Visibility(Visibility::Collapsed); + } catch (...) { + } + } + g_slotButton = nullptr; +} + +} // namespace + +BOOL Wh_ModInit() { + Wh_Log(L">"); + LoadSettings(); + SelectBackend(); + EnsureMessageWindow(); + if (g_backend.load() == TaskbarBackend::Win11Xaml) { + HookTaskbarDllSymbols(); + if (HMODULE m = GetTaskbarViewModuleHandle()) { + g_taskbarViewDllLoaded = true; + HookTaskbarViewDllSymbols(m); + } else { + HMODULE kb = GetModuleHandleW(L"kernelbase.dll"); + auto pLoad = reinterpret_cast(GetProcAddress(kb, "LoadLibraryExW")); + WindhawkUtils::SetFunctionHook(pLoad, LoadLibraryExW_Hook, &LoadLibraryExW_Original); + } + } + StartTimers(); + UpdateTrayIcon(); + ApplyEngineToBackends(); + if (BootstrapFromCache()) { + ApplyEngineToBackends(); + } + RequestRefresh(); + return TRUE; +} + +void Wh_ModAfterInit() { + Wh_Log(L">"); + if (g_backend.load() == TaskbarBackend::Win11Xaml && !g_taskbarViewDllLoaded) { + if (HMODULE m = GetTaskbarViewModuleHandle()) { + if (!g_taskbarViewDllLoaded.exchange(true)) { + if (HookTaskbarViewDllSymbols(m)) Wh_ApplyHookOperations(); + } + } + } + ApplyEngineToBackends(); +} + +void Wh_ModBeforeUninit() { + g_unloading = true; + ShutdownUi(); +} + +void Wh_ModUninit() { + Wh_Log(L">"); +} + +void Wh_ModSettingsChanged() { + Wh_Log(L"Settings changed"); + const bool wasSoundEnabled = g_settings.playPrayerNotification; + auto oldBackend = g_backend.load(); + LoadSettings(); + SelectBackend(); + if (oldBackend != g_backend.load()) { + if (g_backend.load() == TaskbarBackend::Win10Overlay) { + if (auto root = g_slotRoot) { + try { + root.Visibility(Visibility::Collapsed); + } catch (...) { + } + } + } else { + DestroyWin10Overlay(); + } + } + if (!wasSoundEnabled && g_settings.playPrayerNotification) { + PlayNotificationSound(); + } + UpdateTrayIcon(); + g_refreshRequested = true; + RequestRefresh(true); + ApplyEngineToBackends(); +} From ef22ec4ea882f020e64aaf498b240081685a4f4e Mon Sep 17 00:00:00 2001 From: omaralhami Date: Fri, 17 Jul 2026 23:01:28 +0300 Subject: [PATCH 02/10] Update PrayerTray to 2.0.9 --- mods/prayertray.wh.cpp | 209 +++++++++++++++++++++++++++++++---------- 1 file changed, 161 insertions(+), 48 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index 912a4b3f56..5f19ee6c5a 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.0.8 +// @version 2.0.9 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -99,7 +99,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.0.8" +#define WH_MOD_VERSION L"2.0.9" #endif #include @@ -154,6 +154,9 @@ constexpr int kNotificationLeadMinutes = 1; constexpr int kCurrentPrayerHighlightMinutes = 2; constexpr int kCacheStaleHours = 6; constexpr double kClusterDistanceKm = 80.0; +constexpr int kScheduleRefreshIntervalMs = 15 * 60 * 1000; +constexpr int kGeoAccessTimeoutMs = 8000; +constexpr int kRunFromWindowTimeoutMs = 3000; enum class PrayerName { Fajr, Dhuhr, Asr, Maghrib, Isha, Count }; @@ -249,6 +252,7 @@ HWND g_messageHwnd = nullptr; UINT_PTR g_uiTimer = 0; UINT_PTR g_repositionTimer = 0; UINT_PTR g_fullscreenTimer = 0; +UINT_PTR g_scheduleTimer = 0; HWND g_win10OverlayHwnd = nullptr; HWND g_flyoutHwnd = nullptr; bool g_flyoutVisible = false; @@ -1402,10 +1406,41 @@ std::optional TryWindowsLocation() { } catch (winrt::hresult_error const&) { } - const auto access = Geolocator::RequestAccessAsync().get(); - if (access != GeolocationAccessStatus::Allowed) { + // RequestAccessAsync has no built-in timeout and can block the refresh + // pipeline forever if the consent prompt never resolves. + auto accessPromise = + std::make_shared>(); + auto accessFuture = accessPromise->get_future(); + std::thread([accessPromise]() { + try { + try { + winrt::init_apartment(winrt::apartment_type::multi_threaded); + } catch (...) { + } + accessPromise->set_value(Geolocator::RequestAccessAsync().get()); + } catch (...) { + try { + accessPromise->set_exception(std::current_exception()); + } catch (...) { + } + } + }).detach(); + + std::optional access; + if (accessFuture.wait_for(std::chrono::milliseconds(kGeoAccessTimeoutMs)) != + std::future_status::ready) { + Wh_Log(L"Windows Location access timed out"); + return std::nullopt; + } + try { + access = accessFuture.get(); + } catch (...) { + Wh_Log(L"Windows Location access failed"); + return std::nullopt; + } + if (!access || *access != GeolocationAccessStatus::Allowed) { Wh_Log(L"Windows Location denied (%d)", - static_cast(access)); + access ? static_cast(*access) : -1); return std::nullopt; } @@ -7517,6 +7552,28 @@ void RequestRefresh(bool fullLocation = false) { std::thread(RefreshSchedulesWorker).detach(); } +void MaybeRequestScheduleRefresh() { + if (g_refreshRunning.load() || g_refreshRequested.load()) { + return; + } + SYSTEMTIME now = GetLocalNow(); + const int todayKey = DateKey(now.wYear, now.wMonth, now.wDay); + bool needsRefresh = false; + { + std::lock_guard lock(g_scheduleMutex); + if (!g_hasCurrentSchedule) { + needsRefresh = g_lastRefreshFailed.load(); + } else { + const int schedKey = DateKey(g_currentSchedule.year, g_currentSchedule.month, + g_currentSchedule.day); + needsRefresh = schedKey != todayKey; + } + } + if (needsRefresh) { + RequestRefresh(false); + } +} + void OpenWindhawkSettings() { ShellExecuteW(nullptr, L"open", L"windhawk:", nullptr, nullptr, SW_SHOWNORMAL); } @@ -7611,8 +7668,6 @@ LRESULT CALLBACK FlyoutMouseHookProc(int nCode, WPARAM wParam, LPARAM lParam) { if (!PtInRect(&rc, pt)) { if (g_messageHwnd) { PostMessageW(g_messageHwnd, WM_PT_HIDE_FLYOUT, 0, 0); - } else { - HideFlyout(); } } } @@ -8044,8 +8099,18 @@ FrameworkElement ResolveMainStack(FrameworkElement root) { bool IsSlotRootAlive() { if (!g_slotInjected) return false; try { - return g_slotRoot && winrt::get_abi(g_slotRoot) != nullptr; + if (!g_slotRoot || winrt::get_abi(g_slotRoot) == nullptr) { + g_slotInjected = false; + return false; + } + // Orphaned after tray XAML rebuild — demote so inject/backoff can recover. + if (!g_slotRoot.XamlRoot()) { + g_slotInjected = false; + return false; + } + return true; } catch (...) { + g_slotInjected = false; return false; } } @@ -8100,6 +8165,7 @@ void ApplyWin11SlotContent(const DisplayContent& content) { top.FlowDirection(FlowDirection::LeftToRight); top.Foreground(brush); bottom.Text(content.bottom); + bottom.FlowDirection(FlowDirection::LeftToRight); bottom.Foreground(brush); g_hasAppliedContent = true; g_lastAppliedVisible = true; @@ -8333,7 +8399,10 @@ bool RunFromWindowThread(HWND hWnd, RunFromWindowThreadProc_t proc, void* param) DWORD tid = GetWindowThreadProcessId(hWnd, nullptr); if (!tid) return false; if (tid == GetCurrentThreadId()) { - proc(param); + try { + proc(param); + } catch (...) { + } return true; } HHOOK hook = SetWindowsHookExW( @@ -8344,7 +8413,10 @@ bool RunFromWindowThread(HWND hWnd, RunFromWindowThreadProc_t proc, void* param) static const UINT m = RegisterWindowMessage(L"Windhawk_RunFromWindowThread_" WH_MOD_ID); if (cwp->message == m) { auto* p = reinterpret_cast(cwp->lParam); - p->proc(p->param); + try { + p->proc(p->param); + } catch (...) { + } } } return CallNextHookEx(nullptr, nCode, wParam, lParam); @@ -8352,9 +8424,12 @@ bool RunFromWindowThread(HWND hWnd, RunFromWindowThreadProc_t proc, void* param) nullptr, tid); if (!hook) return false; Param p{proc, param}; - SendMessageW(hWnd, msg, 0, reinterpret_cast(&p)); + DWORD_PTR result = 0; + const BOOL sent = SendMessageTimeoutW( + hWnd, msg, 0, reinterpret_cast(&p), + SMTO_ABORTIFHUNG | SMTO_NORMAL, kRunFromWindowTimeoutMs, &result); UnhookWindowsHookEx(hook); - return true; + return sent != FALSE; } HWND FindCurrentProcessTaskbarWnd() { @@ -8377,38 +8452,50 @@ HWND FindCurrentProcessTaskbarWnd() { struct SlotApplyParam { DisplayContent content; }; void ApplyWin11FromThread(SlotApplyParam* param) { - DisplayContent content = param ? param->content : FormatTaskbarDisplay(); - if (IsSlotRootAlive()) { - ApplyWin11SlotContent(content); - g_injectRetryMs = 400; - return; - } - bool injected = false; - for (auto it = g_observedElements.begin(); it != g_observedElements.end();) { - auto element = it->get(); - if (!element) { - it = g_observedElements.erase(it); - continue; - } + try { + DisplayContent content = param ? param->content : FormatTaskbarDisplay(); try { - if (auto xr = element.XamlRoot()) { - if (ApplyWin11Style(xr, content)) { - injected = true; - break; + if (IsSlotRootAlive()) { + ApplyWin11SlotContent(content); + g_injectRetryMs = 400; + return; + } + } catch (...) { + g_slotInjected = false; + } + bool injected = false; + for (auto it = g_observedElements.begin(); it != g_observedElements.end();) { + auto element = it->get(); + if (!element) { + it = g_observedElements.erase(it); + continue; + } + try { + if (auto xr = element.XamlRoot()) { + if (ApplyWin11Style(xr, content)) { + injected = true; + break; + } } + } catch (...) { + } + ++it; + } + try { + if (IsSlotRootAlive()) { + ApplyWin11SlotContent(content); + g_injectRetryMs = 400; + return; } } catch (...) { + g_slotInjected = false; } - ++it; - } - if (IsSlotRootAlive()) { - ApplyWin11SlotContent(content); - g_injectRetryMs = 400; - return; - } - if (!injected) { - const int next = std::min(3000, std::max(400, g_injectRetryMs.load() * 2)); - g_injectRetryMs = next; + if (!injected) { + const int next = std::min(3000, std::max(400, g_injectRetryMs.load() * 2)); + g_injectRetryMs = next; + } + } catch (...) { + g_slotInjected = false; } } @@ -8582,11 +8669,14 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara switch (msg) { case WM_TIMER: if (wParam == 1) { + MaybeRequestScheduleRefresh(); ApplyEngineToBackends(); CheckNotifications(); RestartUiTimer(); } else if (wParam == 2) { RepositionWin10Overlay(); + } else if (wParam == 4) { + RequestRefresh(false); } return 0; case WM_PT_UI_TICK: @@ -8635,15 +8725,19 @@ void StartTimers() { RestartUiTimer(); g_repositionTimer = SetTimer(g_messageHwnd, 2, 2000, nullptr); g_fullscreenTimer = SetTimer(nullptr, 3, 500, FullscreenTimerProc); + g_scheduleTimer = + SetTimer(g_messageHwnd, 4, kScheduleRefreshIntervalMs, nullptr); } void StopTimers() { if (g_messageHwnd) { KillTimer(g_messageHwnd, 1); KillTimer(g_messageHwnd, 2); + KillTimer(g_messageHwnd, 4); } g_uiTimer = 0; g_repositionTimer = 0; + g_scheduleTimer = 0; g_lastUiTimerIntervalMs = -1; if (g_fullscreenTimer) { KillTimer(nullptr, g_fullscreenTimer); @@ -8651,6 +8745,26 @@ void StopTimers() { } } +void ClearWin11SlotOnUiThread(void*) { + try { + if (g_slotParentGrid) { + RemovePrayerTraySlotFromGrid(g_slotParentGrid); + } else if (g_slotRoot) { + g_slotRoot.Visibility(Visibility::Collapsed); + } + } catch (...) { + } + g_loadedRevokers.clear(); + g_observedElements.clear(); + g_slotRoot = nullptr; + g_slotButton = nullptr; + g_topTextBlock = nullptr; + g_bottomTextBlock = nullptr; + g_slotParentGrid = nullptr; + g_slotInjected = false; + g_hasAppliedContent = false; +} + void ShutdownUi() { StopTimers(); HideFlyout(); @@ -8661,19 +8775,18 @@ void ShutdownUi() { DestroyMenu(g_contextMenu); g_contextMenu = nullptr; } - if (g_messageHwnd) { - DestroyWindow(g_messageHwnd); - g_messageHwnd = nullptr; - } - g_loadedRevokers.clear(); - g_observedElements.clear(); - if (auto root = g_slotRoot) { + if (HWND taskbar = FindCurrentProcessTaskbarWnd()) { + RunFromWindowThread(taskbar, ClearWin11SlotOnUiThread, nullptr); + } else { try { - root.Visibility(Visibility::Collapsed); + ClearWin11SlotOnUiThread(nullptr); } catch (...) { } } - g_slotButton = nullptr; + if (g_messageHwnd) { + DestroyWindow(g_messageHwnd); + g_messageHwnd = nullptr; + } } } // namespace From f887134610598d6385d65dfc6e5377d8e37a31e9 Mon Sep 17 00:00:00 2001 From: omaralhami Date: Fri, 17 Jul 2026 23:15:36 +0300 Subject: [PATCH 03/10] Update PrayerTray to 2.0.12 Co-authored-by: Cursor --- mods/prayertray.wh.cpp | 5438 +--------------------------------------- 1 file changed, 61 insertions(+), 5377 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index 5f19ee6c5a..f117e2df28 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.0.9 +// @version 2.0.12 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -99,7 +99,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.0.9" +#define WH_MOD_VERSION L"2.0.12" #endif #include @@ -288,6 +288,7 @@ FrameworkElement g_slotRoot{nullptr}; Controls::Grid g_slotParentGrid{nullptr}; std::atomic g_slotPointerOver; std::atomic g_slotPointerPressed; +std::atomic g_slotRightPressed; std::atomic g_lastCommandId; std::atomic g_lastCommandTick; bool g_hasAppliedContent; @@ -1960,5357 +1961,10 @@ DisplayContent FormatTaskbarDisplay() { return content; } -// BEGIN_EMBEDDED_NOTIFICATION_SOUND -// auto-generated -static const unsigned char kAllahAkbarMp3[] = { - 0x49, 0x44, 0x33, 0x04, 0x00, 0x00, 0x00, 0x00, 0x01, 0x70, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, - 0x00, 0x12, 0x00, 0x00, 0x03, 0x6D, 0x61, 0x6A, 0x6F, 0x72, 0x5F, 0x62, 0x72, 0x61, 0x6E, 0x64, - 0x00, 0x6D, 0x70, 0x34, 0x32, 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, - 0x03, 0x6D, 0x69, 0x6E, 0x6F, 0x72, 0x5F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x00, 0x30, - 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x03, 0x63, 0x6F, 0x6D, 0x70, - 0x61, 0x74, 0x69, 0x62, 0x6C, 0x65, 0x5F, 0x62, 0x72, 0x61, 0x6E, 0x64, 0x73, 0x00, 0x69, 0x73, - 0x6F, 0x6D, 0x6D, 0x70, 0x34, 0x32, 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x26, 0x00, - 0x00, 0x03, 0x63, 0x6F, 0x6D, 0x2E, 0x73, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x61, 0x6E, - 0x64, 0x72, 0x6F, 0x69, 0x64, 0x2E, 0x75, 0x74, 0x63, 0x5F, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, - 0x00, 0x2B, 0x30, 0x33, 0x30, 0x30, 0x00, 0x54, 0x58, 0x58, 0x58, 0x00, 0x00, 0x00, 0x18, 0x00, - 0x00, 0x03, 0x63, 0x6F, 0x6D, 0x2E, 0x61, 0x6E, 0x64, 0x72, 0x6F, 0x69, 0x64, 0x2E, 0x76, 0x65, - 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x00, 0x31, 0x35, 0x00, 0x54, 0x50, 0x45, 0x31, 0x00, 0x00, 0x00, - 0x14, 0x00, 0x00, 0x03, 0x20, 0x7C, 0x20, 0x42, 0x79, 0x20, 0x58, 0x39, 0x20, 0x43, 0x6F, 0x6E, - 0x76, 0x65, 0x72, 0x74, 0x65, 0x72, 0x00, 0x54, 0x53, 0x53, 0x45, 0x00, 0x00, 0x00, 0x0F, 0x00, - 0x00, 0x03, 0x4C, 0x61, 0x76, 0x66, 0x36, 0x30, 0x2E, 0x31, 0x36, 0x2E, 0x31, 0x30, 0x30, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFB, 0x90, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x6E, - 0x66, 0x6F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x01, 0x4D, 0x0E, 0x00, 0x05, - 0x07, 0x0A, 0x0C, 0x0F, 0x11, 0x14, 0x16, 0x19, 0x1B, 0x1E, 0x20, 0x23, 0x25, 0x28, 0x2A, 0x2D, - 0x2F, 0x32, 0x34, 0x37, 0x39, 0x3C, 0x3E, 0x41, 0x43, 0x46, 0x48, 0x4B, 0x4D, 0x50, 0x52, 0x55, - 0x59, 0x5B, 0x5E, 0x60, 0x63, 0x65, 0x68, 0x6A, 0x6D, 0x6F, 0x72, 0x74, 0x77, 0x79, 0x7C, 0x7E, - 0x81, 0x83, 0x86, 0x88, 0x8B, 0x8D, 0x90, 0x92, 0x95, 0x97, 0x9A, 0x9C, 0x9F, 0xA1, 0xA4, 0xA6, - 0xA9, 0xAD, 0xAF, 0xB2, 0xB4, 0xB7, 0xB9, 0xBC, 0xBE, 0xC1, 0xC3, 0xC6, 0xC8, 0xCB, 0xCD, 0xD0, - 0xD2, 0xD5, 0xD7, 0xDA, 0xDC, 0xDF, 0xE1, 0xE4, 0xE6, 0xE9, 0xEB, 0xEE, 0xF0, 0xF3, 0xF5, 0xF8, - 0xFA, 0xFD, 0x00, 0x00, 0x00, 0x00, 0x4C, 0x61, 0x76, 0x63, 0x36, 0x30, 0x2E, 0x33, 0x31, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x03, 0x87, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x01, 0x4D, 0x0E, 0x77, 0xAF, 0x33, 0xAE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 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, 0xFB, 0x90, 0x64, 0x00, - 0x08, 0x02, 0xFE, 0x3F, 0xB7, 0x9B, 0x06, 0x1A, 0xF0, 0x20, 0x80, 0x17, 0x8C, 0x00, 0x41, 0x00, - 0x0D, 0x69, 0x60, 0xF4, 0xAC, 0x18, 0xB3, 0xC1, 0x3F, 0x25, 0x9E, 0x80, 0xC3, 0x09, 0x78, 0x00, - 0x12, 0x01, 0x50, 0xBF, 0x71, 0xC0, 0xA1, 0x00, 0x58, 0x47, 0x72, 0xED, 0xAE, 0xB7, 0xA2, 0x10, - 0xE4, 0x47, 0x5D, 0xF2, 0x86, 0x0B, 0x0B, 0x10, 0x30, 0x81, 0xEB, 0x21, 0x0E, 0x99, 0x98, 0x42, - 0x6D, 0xA3, 0x09, 0xEE, 0x33, 0xDC, 0x44, 0x1E, 0x99, 0x89, 0xEC, 0x46, 0x1E, 0x9B, 0x47, 0x2E, - 0x13, 0x9A, 0x23, 0x08, 0x73, 0xEC, 0x44, 0x03, 0x30, 0x85, 0xA7, 0xE9, 0xE9, 0x5F, 0xE3, 0xCC, - 0xD2, 0xBC, 0xC9, 0xCC, 0xB2, 0x78, 0x48, 0x22, 0xBF, 0xFD, 0x27, 0x85, 0x7C, 0x21, 0x00, 0x13, - 0xCE, 0x08, 0x09, 0xF5, 0x88, 0x04, 0xE1, 0x82, 0x01, 0x61, 0x3F, 0xE2, 0xA7, 0xC7, 0x38, 0x00, - 0x63, 0x20, 0xA0, 0xAA, 0xDF, 0x04, 0xC3, 0x01, 0x62, 0xE0, 0x83, 0x56, 0xA2, 0x93, 0x8B, 0xA1, - 0xBA, 0x4E, 0x7F, 0x4F, 0xA3, 0xE7, 0xFF, 0x7F, 0xE9, 0x10, 0x5D, 0xBA, 0xCF, 0xFF, 0xFA, 0xC4, - 0xBF, 0x3A, 0x46, 0x9E, 0x8D, 0xB9, 0x52, 0x82, 0x80, 0xBD, 0x29, 0xDA, 0x9C, 0x82, 0xE4, 0x46, - 0x8E, 0xB5, 0x9F, 0x94, 0x7E, 0x73, 0xF3, 0x99, 0x63, 0x6A, 0x8A, 0xDF, 0x9F, 0xC0, 0xC7, 0xEC, - 0x0B, 0xDD, 0x7E, 0x0F, 0x47, 0x93, 0xB4, 0x4E, 0xCE, 0x9F, 0x27, 0x6E, 0xBD, 0xD4, 0xDC, 0x9D, - 0x3E, 0x7B, 0x28, 0x3C, 0x10, 0xE6, 0x04, 0x33, 0x10, 0x32, 0x34, 0xC2, 0x19, 0x1D, 0xE5, 0x34, - 0x01, 0xFE, 0x6B, 0xAD, 0x3E, 0xFD, 0x88, 0xA5, 0x18, 0xCA, 0x4D, 0xF6, 0xD4, 0x17, 0xA5, 0x64, - 0x99, 0x9F, 0xF7, 0x43, 0x8F, 0x6D, 0xD0, 0x44, 0x52, 0x1C, 0x60, 0x10, 0x72, 0x70, 0xFB, 0xFF, - 0xC4, 0x1A, 0x21, 0xA2, 0xBC, 0x4C, 0x7F, 0xFF, 0xEA, 0x1F, 0x79, 0x48, 0x04, 0x18, 0x11, 0x0B, - 0x08, 0x45, 0x8E, 0x6D, 0xFE, 0x33, 0x1E, 0xAF, 0xA7, 0x0C, 0xFC, 0xC9, 0x3A, 0x48, 0x0B, 0x8D, - 0x3D, 0x72, 0x03, 0x5D, 0x5E, 0x78, 0xE6, 0x0C, 0xEE, 0x9F, 0x07, 0x5B, 0x95, 0x8C, 0x53, 0x4A, - 0x80, 0x0A, 0x46, 0x81, 0xE1, 0xCE, 0x8B, 0x22, 0x30, 0x42, 0x20, 0x00, 0xDC, 0xF9, 0xCE, 0xAF, - 0x5D, 0x04, 0x64, 0x31, 0x4E, 0xA7, 0x70, 0x40, 0x0C, 0x7A, 0xB9, 0xEF, 0x65, 0x74, 0x68, 0x77, - 0xDF, 0xFF, 0xF0, 0xEF, 0x08, 0xDC, 0x38, 0xFC, 0x63, 0xA4, 0xD5, 0x6A, 0x15, 0xF4, 0x15, 0x0B, - 0x34, 0x75, 0x4C, 0x86, 0x48, 0x05, 0x49, 0x25, 0x60, 0x83, 0x22, 0xF5, 0x1E, 0x9C, 0x32, 0xB3, - 0x53, 0xB4, 0xB2, 0x7E, 0xCB, 0xAD, 0xF1, 0x43, 0x77, 0xC4, 0xD6, 0xBB, 0x02, 0x99, 0xDC, 0x81, - 0xA3, 0x87, 0x10, 0x03, 0x09, 0x06, 0x16, 0x2E, 0xD3, 0x04, 0x94, 0x43, 0xA2, 0x1C, 0x82, 0x64, - 0x88, 0x13, 0x01, 0xDA, 0x65, 0x02, 0xED, 0x66, 0xB3, 0xC6, 0xA2, 0xC6, 0xFF, 0xFB, 0x92, 0x64, - 0x20, 0x8C, 0x03, 0x83, 0x58, 0x3F, 0x93, 0x26, 0x2C, 0x70, 0x4C, 0xCA, 0xF8, 0x33, 0x20, 0x25, - 0xB6, 0xCE, 0x6D, 0x5C, 0xFC, 0x0C, 0x98, 0x6F, 0xC1, 0x61, 0x92, 0xA1, 0x18, 0x60, 0x8C, 0xE1, - 0xDD, 0xA7, 0x9D, 0x9C, 0xD3, 0x79, 0x85, 0x9D, 0x07, 0x37, 0x76, 0x63, 0xE6, 0xE8, 0x22, 0x54, - 0x8D, 0x11, 0x3B, 0xA0, 0x88, 0xF0, 0xFF, 0x55, 0x64, 0x12, 0x6C, 0x68, 0x1C, 0x45, 0xA6, 0x23, - 0x31, 0x7B, 0x3F, 0xFC, 0x2B, 0x09, 0x35, 0x43, 0xD8, 0x80, 0xFE, 0xBF, 0xF9, 0xC0, 0x31, 0xE0, - 0x00, 0x08, 0x02, 0x8A, 0x40, 0x38, 0xA6, 0x24, 0xD5, 0x44, 0xB5, 0x64, 0x3F, 0xC7, 0x03, 0xB4, - 0xD7, 0x82, 0xA5, 0x25, 0xB3, 0xF9, 0xB0, 0x56, 0x8D, 0x9B, 0xB1, 0x59, 0x67, 0x99, 0x8C, 0xC4, - 0x3A, 0x84, 0x7D, 0x87, 0x23, 0xEF, 0x77, 0x51, 0x2C, 0xDC, 0xFD, 0x6C, 0x96, 0x93, 0xA5, 0x55, - 0xD7, 0x69, 0xD4, 0xFD, 0x7F, 0xFF, 0xBD, 0x3F, 0x7F, 0xC9, 0xD3, 0xFC, 0xCC, 0x03, 0xB8, 0x80, - 0xF5, 0xC4, 0x67, 0x7C, 0x12, 0x2A, 0x58, 0x03, 0xF0, 0x00, 0x60, 0xCD, 0x29, 0x48, 0x57, 0x83, - 0x79, 0x74, 0xC5, 0x3C, 0xCA, 0x5D, 0x6B, 0x8F, 0x19, 0x0C, 0xB5, 0x8C, 0xC3, 0x7F, 0x45, 0xD8, - 0x87, 0xD4, 0x3C, 0xA2, 0x78, 0xC9, 0xA0, 0x92, 0x27, 0xAC, 0x7B, 0xCB, 0xB1, 0x37, 0x4E, 0x30, - 0xA7, 0x2F, 0x2B, 0x6C, 0x9A, 0x26, 0x52, 0x32, 0x53, 0x6A, 0x41, 0x5A, 0xC5, 0x0C, 0xAB, 0x40, - 0x54, 0xF2, 0xCB, 0xD2, 0x2B, 0x31, 0xAD, 0x2E, 0xF9, 0xF4, 0x38, 0x35, 0x60, 0xE4, 0xCE, 0x88, - 0x84, 0x14, 0xE0, 0x96, 0xA8, 0xEA, 0x27, 0xA6, 0x0B, 0x43, 0xA5, 0x2C, 0x4B, 0x43, 0x38, 0xD3, - 0x44, 0x57, 0xDC, 0x9C, 0x81, 0x22, 0x6C, 0x2F, 0xFA, 0xE7, 0x4C, 0x9B, 0xA2, 0xFF, 0x58, 0x70, - 0xFF, 0x91, 0xF7, 0xCE, 0x9F, 0x84, 0x27, 0xFA, 0x22, 0x07, 0x3C, 0x2E, 0xF5, 0xE9, 0x58, 0xE1, - 0x11, 0x4A, 0xAC, 0xC5, 0x12, 0x4C, 0xC8, 0x1B, 0x2C, 0x9B, 0x04, 0x6C, 0xD0, 0x59, 0xA5, 0xAB, - 0x49, 0xB9, 0x60, 0x00, 0x00, 0x6C, 0x34, 0x16, 0x4C, 0xE9, 0x46, 0xB3, 0x4A, 0x2E, 0x92, 0x32, - 0xB4, 0x21, 0xC8, 0x4D, 0x63, 0x72, 0xCC, 0xCD, 0xB0, 0x58, 0x02, 0x93, 0xB8, 0x4F, 0x44, 0x1B, - 0x88, 0x7E, 0xFF, 0x7B, 0xD3, 0x79, 0xC1, 0x2F, 0xA8, 0x5E, 0xF6, 0x07, 0x98, 0x9E, 0x01, 0x1F, - 0xCD, 0xDF, 0x50, 0x7F, 0xFF, 0x31, 0x3F, 0xEB, 0x37, 0xFE, 0x07, 0xCF, 0xC4, 0x06, 0x60, 0xAC, - 0x9D, 0xE3, 0xB7, 0xFC, 0x33, 0xFF, 0x82, 0x3A, 0x00, 0x06, 0x52, 0xBA, 0x95, 0xEC, 0xA3, 0x70, - 0x4A, 0xF0, 0x08, 0xD0, 0x98, 0xB5, 0x8C, 0x35, 0x7A, 0xAC, 0x8F, 0xF0, 0xD6, 0x3F, 0xD0, 0xC0, - 0x98, 0x90, 0xC8, 0xAD, 0xC5, 0xE1, 0x39, 0x91, 0xA7, 0x23, 0x92, 0x9A, 0xDA, 0x09, 0x86, 0x39, - 0x40, 0x9E, 0xEC, 0x6F, 0xC9, 0x58, 0x79, 0x51, 0x51, 0x69, 0x1C, 0x2F, 0x2D, 0xD4, 0xFF, 0xFB, - 0x92, 0x64, 0x1B, 0x08, 0x83, 0x06, 0x66, 0x42, 0xCB, 0x23, 0x13, 0xF0, 0x50, 0x63, 0x28, 0x59, - 0x18, 0x23, 0x3E, 0x4B, 0x20, 0xBF, 0x08, 0xAC, 0x84, 0x6A, 0xC8, 0xF5, 0x10, 0x61, 0xC8, 0x20, - 0x8C, 0xF8, 0x5D, 0xF6, 0x3A, 0xA4, 0xA5, 0x06, 0x44, 0xB3, 0x56, 0x8C, 0x67, 0xB2, 0xAB, 0x26, - 0xBA, 0x6B, 0xD9, 0x3B, 0x7E, 0x86, 0x0D, 0x35, 0x35, 0x2F, 0xDF, 0xEC, 0x54, 0xB5, 0x93, 0x73, - 0x83, 0x07, 0xFE, 0x9D, 0x4F, 0x9D, 0x66, 0x74, 0x35, 0xA7, 0x1F, 0x0C, 0x28, 0x00, 0x20, 0x05, - 0x94, 0x04, 0x8C, 0x42, 0x40, 0xBB, 0x94, 0x99, 0x28, 0x81, 0x26, 0x15, 0x6B, 0x33, 0x20, 0x95, - 0x33, 0x76, 0xC6, 0x7E, 0x18, 0xAA, 0xB5, 0x61, 0xA6, 0xC2, 0xFD, 0xA8, 0x6B, 0x38, 0xE8, 0x43, - 0x2B, 0x29, 0xB1, 0x32, 0xEE, 0xD7, 0xE7, 0x5D, 0x1B, 0x77, 0xDF, 0x2C, 0x50, 0x71, 0xF9, 0x7F, - 0x3C, 0x8F, 0xD0, 0xF7, 0xD7, 0xDF, 0x65, 0xEF, 0xE1, 0xC5, 0xF8, 0x75, 0xFC, 0x2F, 0xF6, 0x4D, - 0x2A, 0x15, 0x3D, 0xAE, 0xFB, 0xBF, 0xF9, 0xF5, 0xFC, 0x6B, 0x7F, 0x5C, 0xFD, 0x90, 0xDE, 0xA4, - 0x11, 0x92, 0x0F, 0xD9, 0xDA, 0x64, 0x76, 0x18, 0x1C, 0x8E, 0xC5, 0x15, 0xD8, 0x54, 0x0A, 0x82, - 0xCA, 0x69, 0x6B, 0x59, 0x4B, 0x8B, 0x95, 0xE1, 0x48, 0x9F, 0x35, 0x22, 0xF7, 0x86, 0x9E, 0xC9, - 0x4F, 0x5D, 0x6C, 0x49, 0x3E, 0x72, 0x65, 0x39, 0xD3, 0x7D, 0x58, 0x9B, 0xE8, 0x27, 0xCB, 0x60, - 0x2D, 0x5F, 0xA2, 0x21, 0xAC, 0xF5, 0x9F, 0x8D, 0xAD, 0x5A, 0xFC, 0x26, 0xEB, 0xDB, 0x10, 0x0B, - 0x40, 0x77, 0x35, 0xBF, 0xA7, 0x33, 0xB2, 0x8C, 0xC6, 0x8F, 0xF5, 0x3E, 0xED, 0x3A, 0x3F, 0xDF, - 0xFF, 0xF5, 0xDF, 0xE6, 0xED, 0xDD, 0xB5, 0x22, 0x2A, 0xDE, 0xD7, 0x19, 0x95, 0x1C, 0xCA, 0x5C, - 0x0F, 0xFA, 0x06, 0x69, 0x30, 0x86, 0xDF, 0x17, 0xF2, 0xC6, 0x85, 0xD6, 0xCC, 0xCB, 0x0B, 0xA1, - 0x8E, 0x91, 0x75, 0x9C, 0x11, 0x26, 0xEA, 0x74, 0x12, 0x7D, 0x17, 0x96, 0x61, 0xA7, 0x1C, 0x48, - 0x45, 0xF1, 0x9D, 0x3D, 0xCD, 0x21, 0xB3, 0xCD, 0xB8, 0x08, 0xDE, 0x70, 0x86, 0xC7, 0x9E, 0x8A, - 0xDB, 0xD3, 0x75, 0xF5, 0x00, 0x00, 0x61, 0x55, 0x15, 0xA6, 0x08, 0x32, 0x08, 0x03, 0x3D, 0x12, - 0x56, 0x6B, 0xB2, 0x06, 0x07, 0xB9, 0x73, 0x72, 0xC6, 0x9A, 0xC8, 0x59, 0x77, 0xA8, 0xCC, 0x6D, - 0xBB, 0x8C, 0xFE, 0x73, 0x68, 0xD9, 0xC3, 0x0A, 0x73, 0x4E, 0x0B, 0x6F, 0x57, 0x16, 0x26, 0x78, - 0x9E, 0xC0, 0xFD, 0x5D, 0xFD, 0x74, 0x9C, 0x89, 0xEC, 0x4B, 0xF8, 0x90, 0xBA, 0x3C, 0xDF, 0xB3, - 0x24, 0xE8, 0xDE, 0x90, 0x65, 0x1F, 0x60, 0x8F, 0xB6, 0xCD, 0x66, 0xDF, 0xF4, 0xE3, 0xF2, 0x9B, - 0xF7, 0x85, 0x8A, 0x5D, 0x64, 0xF3, 0x28, 0xF7, 0x6B, 0xFF, 0x7F, 0xAF, 0x48, 0x10, 0x80, 0x14, - 0x3D, 0x30, 0xCB, 0xA7, 0x51, 0x76, 0xEF, 0xB9, 0x70, 0xA2, 0x4B, 0xEB, 0xA2, 0x69, 0xF6, 0x77, - 0xFF, 0xFB, 0x92, 0x64, 0x36, 0x00, 0xD2, 0xC7, 0x0F, 0xC2, 0xCB, 0x09, 0x11, 0x92, 0x45, 0xE4, - 0xC8, 0x62, 0x0C, 0xC2, 0xC0, 0x09, 0x9C, 0x3B, 0x13, 0x2C, 0x30, 0x64, 0x80, 0xF4, 0x8D, 0x21, - 0xC4, 0x60, 0x8D, 0x40, 0xA8, 0x48, 0x32, 0x9F, 0x9F, 0x16, 0x23, 0x0F, 0x76, 0x54, 0xFC, 0xB7, - 0x3A, 0x0B, 0x50, 0xA8, 0x2A, 0x2C, 0x23, 0xA0, 0x70, 0xC4, 0xA5, 0x53, 0xE9, 0x60, 0xAA, 0x12, - 0xE0, 0x02, 0x2C, 0x58, 0x8A, 0x87, 0xF5, 0x22, 0xB5, 0xB1, 0x23, 0x62, 0xAF, 0x91, 0xAF, 0x4F, - 0xBD, 0x22, 0xBA, 0xB2, 0x14, 0x5F, 0xA0, 0x04, 0x82, 0x6B, 0xBA, 0xAA, 0xF7, 0xE4, 0xAF, 0x12, - 0x14, 0x44, 0xB2, 0x11, 0x65, 0x91, 0x8D, 0x6A, 0xA7, 0x1F, 0x2E, 0xF3, 0xD7, 0xB0, 0x2C, 0xEA, - 0x5E, 0x1A, 0x3C, 0x7C, 0xDB, 0x18, 0x51, 0x81, 0xF0, 0xA8, 0xF0, 0x71, 0xA9, 0x10, 0x0A, 0x30, - 0xA2, 0xC5, 0x6E, 0x40, 0x11, 0x4D, 0xBC, 0x8B, 0xF7, 0x34, 0x30, 0x95, 0x94, 0xEC, 0x59, 0xDB, - 0x14, 0x6C, 0x7E, 0x4D, 0xA0, 0x4A, 0x66, 0x25, 0x96, 0xCB, 0x1F, 0x0C, 0x29, 0x0B, 0xDF, 0x7B, - 0xEF, 0x42, 0xEA, 0x42, 0xCF, 0x07, 0x45, 0xEB, 0x5B, 0xE5, 0xAF, 0x17, 0x52, 0x34, 0xFE, 0x3D, - 0x9E, 0x5D, 0x93, 0xDC, 0xA6, 0x5D, 0xF5, 0x2C, 0x90, 0x58, 0x77, 0x83, 0x65, 0x4E, 0x85, 0x43, - 0x05, 0xD1, 0x0A, 0x8C, 0x04, 0xC1, 0xA1, 0x51, 0x48, 0x9E, 0x88, 0xBB, 0xCD, 0x20, 0xCA, 0x5A, - 0x16, 0x5C, 0xCA, 0x19, 0x4F, 0xB5, 0x9D, 0x06, 0xAB, 0xF9, 0x47, 0x74, 0xBF, 0x6F, 0xF3, 0x9F, - 0xA9, 0x86, 0x47, 0x74, 0x74, 0xAA, 0x1E, 0x08, 0x3B, 0x30, 0x18, 0x0F, 0x09, 0xFB, 0x31, 0x82, - 0xAB, 0x5E, 0x69, 0xF1, 0x36, 0xDF, 0x14, 0xC2, 0x7F, 0xFC, 0x22, 0x24, 0xB9, 0x1F, 0x48, 0xA2, - 0xB6, 0x6A, 0xCA, 0xAD, 0x3E, 0x0E, 0x9C, 0x06, 0x2E, 0xB7, 0x06, 0x69, 0x94, 0x33, 0xBF, 0x92, - 0xB0, 0xEC, 0x3B, 0x2E, 0x71, 0x4C, 0x78, 0xE3, 0xF9, 0xA7, 0xF3, 0x3D, 0xA2, 0x7F, 0xF6, 0x41, - 0x2B, 0xFE, 0xCB, 0xA4, 0xFF, 0xC3, 0x5D, 0xA3, 0xC5, 0x2D, 0x9D, 0xEF, 0x7D, 0x9F, 0xCF, 0x7B, - 0xC7, 0xEF, 0x67, 0x59, 0xFF, 0xA9, 0x58, 0xA8, 0xD3, 0xBB, 0xEA, 0x4F, 0xD6, 0xC0, 0x0D, 0x54, - 0xA0, 0xA0, 0x08, 0x48, 0x0F, 0x8A, 0x1C, 0xE2, 0x92, 0x91, 0x49, 0x6A, 0x38, 0xC1, 0x73, 0x6B, - 0xDC, 0xD5, 0x38, 0xF7, 0x04, 0xF2, 0x7F, 0x49, 0xDA, 0xC2, 0xB3, 0x52, 0xAE, 0xCD, 0x11, 0x42, - 0x0E, 0x8B, 0x58, 0x19, 0xF5, 0xA2, 0xF1, 0xD6, 0xBE, 0xB1, 0xD3, 0x66, 0x0B, 0xBA, 0xF4, 0x3A, - 0x9F, 0xFF, 0xEA, 0xA3, 0xFA, 0x3A, 0xBD, 0x0D, 0x48, 0x08, 0xFC, 0xB2, 0x20, 0xD8, 0xDB, 0xE3, - 0x3C, 0x8B, 0x0C, 0x1E, 0xC9, 0x0D, 0xAA, 0x2E, 0x91, 0x27, 0x3C, 0x47, 0x65, 0x3E, 0xCF, 0x4D, - 0x08, 0xD8, 0xD0, 0xDC, 0x58, 0x2A, 0x79, 0xCA, 0x30, 0x30, 0xE3, 0xF5, 0x03, 0x93, 0x43, 0x06, - 0xC8, 0x6D, 0xFF, 0xFB, 0x92, 0x64, 0x60, 0x8C, 0x82, 0xE2, 0x1E, 0x41, 0x83, 0x0F, 0x19, 0x42, - 0x3A, 0x24, 0xA8, 0x96, 0x0C, 0x23, 0x58, 0x0B, 0x68, 0x9D, 0x0A, 0x4C, 0xA4, 0x66, 0x81, 0x1D, - 0x21, 0x61, 0xC4, 0x80, 0x8B, 0xC8, 0x5E, 0x65, 0xD4, 0xA8, 0x3C, 0xF0, 0x45, 0x85, 0x8C, 0xB4, - 0x14, 0x9F, 0x7A, 0x06, 0x29, 0x8C, 0x1E, 0xD3, 0xF1, 0x5C, 0x98, 0xBD, 0x84, 0xE9, 0x16, 0x44, - 0x1A, 0x15, 0x2A, 0x55, 0x64, 0x55, 0xBC, 0x15, 0x30, 0x58, 0xDB, 0xC5, 0x4F, 0xBE, 0x8B, 0x5C, - 0x91, 0xBB, 0x0F, 0x59, 0x45, 0x48, 0x76, 0x40, 0x81, 0x34, 0x0C, 0x10, 0x5E, 0x6A, 0xE5, 0x27, - 0x94, 0xE2, 0xD2, 0x1B, 0xAB, 0xE2, 0xA2, 0xD2, 0x28, 0xFB, 0xE1, 0x1A, 0xA9, 0xCB, 0x3E, 0xAB, - 0xEA, 0x24, 0xDE, 0x25, 0xEB, 0xEF, 0xAB, 0xAF, 0x46, 0x65, 0x6A, 0x2F, 0x65, 0x3F, 0x4E, 0x62, - 0x44, 0x21, 0xB7, 0x6E, 0xA6, 0xF8, 0xC5, 0x47, 0x99, 0x32, 0xDD, 0x17, 0x9E, 0xED, 0x46, 0x46, - 0xC5, 0xBB, 0xA4, 0x3F, 0xA7, 0x31, 0xD2, 0xA7, 0xED, 0xC5, 0x74, 0x58, 0xFC, 0x06, 0x81, 0x05, - 0x5A, 0x73, 0x53, 0x13, 0x31, 0x57, 0x04, 0x54, 0xA2, 0x03, 0x94, 0x48, 0xF8, 0xC2, 0x15, 0x00, - 0x89, 0x6D, 0x54, 0xAF, 0x7C, 0xBE, 0xE0, 0xDE, 0xCD, 0x74, 0x56, 0xE6, 0x7F, 0x72, 0xC9, 0xFB, - 0x73, 0xCC, 0xCF, 0xCB, 0x76, 0xFA, 0xCD, 0x5F, 0x4D, 0xF3, 0x3F, 0xA7, 0x33, 0x39, 0x6C, 0x4E, - 0xBE, 0x63, 0x86, 0x71, 0x86, 0x2A, 0x90, 0x0B, 0x5E, 0x75, 0x58, 0xCC, 0x5A, 0x49, 0x8B, 0x07, - 0x5E, 0x06, 0x1B, 0x1E, 0x20, 0x78, 0xF5, 0xB9, 0x2F, 0x58, 0xEE, 0x48, 0x7B, 0x6F, 0x2E, 0xF9, - 0xE1, 0x0D, 0x29, 0x49, 0x94, 0x99, 0xD8, 0x40, 0x08, 0x3A, 0xE2, 0xC1, 0xBD, 0x84, 0x70, 0xAA, - 0xCC, 0xAB, 0xE9, 0x03, 0x58, 0x07, 0x22, 0xE3, 0x8C, 0x4E, 0xCE, 0x74, 0x95, 0xBA, 0xE5, 0xF4, - 0x8C, 0x1A, 0xB8, 0x2E, 0x11, 0x18, 0x64, 0xF8, 0x64, 0x2C, 0xE7, 0x8F, 0x42, 0x92, 0xC8, 0x2E, - 0x44, 0xF0, 0x64, 0x48, 0x80, 0x2A, 0x52, 0xE0, 0x58, 0xA2, 0x40, 0xD6, 0xBC, 0x73, 0x6E, 0xB4, - 0xF1, 0x40, 0xF0, 0xCF, 0x16, 0xBB, 0xFD, 0x11, 0xEA, 0xFF, 0xAE, 0x48, 0x65, 0x01, 0x6C, 0x15, - 0x0A, 0x07, 0x82, 0xC0, 0x9B, 0x5D, 0x42, 0xA7, 0x36, 0xD4, 0x7E, 0x4D, 0x8E, 0x50, 0x6F, 0x64, - 0x3E, 0x8F, 0x9F, 0xCF, 0xA4, 0xA7, 0x67, 0xFD, 0x29, 0xEA, 0xCD, 0xA3, 0xA8, 0xE6, 0xA9, 0x4C, - 0x93, 0xC6, 0x24, 0xB2, 0x45, 0x2A, 0x50, 0x6D, 0xE7, 0x07, 0xEF, 0x53, 0xD4, 0xB1, 0x0A, 0x9E, - 0x07, 0xD6, 0xB5, 0x98, 0x2C, 0x54, 0xA1, 0x04, 0xCC, 0xAA, 0xF3, 0x2B, 0x62, 0x86, 0xA5, 0xD1, - 0x8C, 0x42, 0x54, 0xD3, 0x8D, 0x50, 0xE6, 0xAC, 0x4C, 0xBB, 0xC9, 0xAE, 0x44, 0xF3, 0x52, 0x79, - 0x27, 0x05, 0x5A, 0x5A, 0xD5, 0x06, 0x90, 0x14, 0x30, 0xA0, 0x83, 0xB1, 0x61, 0xAC, 0x89, 0x53, - 0x0F, 0x3F, 0xB5, 0x42, 0xFF, 0xFB, 0x92, 0x64, 0x83, 0x0C, 0x82, 0xC7, 0x30, 0xC2, 0x03, 0x09, - 0x19, 0xE0, 0x44, 0xE3, 0xA8, 0x82, 0x0C, 0x23, 0x84, 0x0B, 0x2C, 0x77, 0x0C, 0x4C, 0x30, 0x68, - 0x81, 0x0F, 0x0B, 0xA2, 0x58, 0x61, 0x0C, 0xA9, 0x89, 0x18, 0x23, 0x01, 0x9D, 0x34, 0x12, 0xE8, - 0xE0, 0x0E, 0xB4, 0x2E, 0x9C, 0x01, 0x3C, 0xD4, 0xA8, 0xC4, 0x73, 0x35, 0xFA, 0xD6, 0x6A, 0xB3, - 0x7E, 0x77, 0x5A, 0xB7, 0xDD, 0xD3, 0x76, 0xE9, 0x3C, 0x33, 0xB3, 0x3D, 0xC8, 0xB7, 0x76, 0xE8, - 0x82, 0xF9, 0xFF, 0x33, 0xA6, 0xBE, 0xFD, 0xBF, 0x76, 0xB0, 0x77, 0xEF, 0xF9, 0x02, 0x41, 0x05, - 0xDA, 0x91, 0xAB, 0xA9, 0x40, 0xD6, 0xAB, 0xB0, 0x1E, 0x2D, 0x2A, 0xA4, 0x93, 0x46, 0x24, 0xD0, - 0x1B, 0x1A, 0x01, 0x94, 0x64, 0x6F, 0xB9, 0xF4, 0x8C, 0xA7, 0xFB, 0xE7, 0x20, 0x96, 0x92, 0x13, - 0x76, 0xA1, 0xE5, 0x41, 0x12, 0xAC, 0x6C, 0x8C, 0xF3, 0x47, 0x9F, 0x47, 0x1C, 0xA7, 0x8D, 0x71, - 0xF6, 0x92, 0x53, 0x89, 0x77, 0x9D, 0xD9, 0xA0, 0xF7, 0x54, 0x77, 0x46, 0x67, 0x92, 0xC5, 0x51, - 0x5E, 0x30, 0xC8, 0xB0, 0xC2, 0xFD, 0x83, 0xDA, 0xAA, 0x9F, 0x3A, 0xFA, 0x00, 0x11, 0xE5, 0x10, - 0x01, 0xA5, 0x67, 0xBD, 0xA5, 0x19, 0xFB, 0xB6, 0xEA, 0xEB, 0xEB, 0x76, 0x8C, 0xCF, 0xFA, 0x00, - 0x47, 0xA0, 0x96, 0xC1, 0x3B, 0xCF, 0xD1, 0x4C, 0x0B, 0x9B, 0x14, 0xD4, 0xC4, 0x4B, 0xCC, 0x43, - 0x28, 0xDA, 0x22, 0x22, 0x8A, 0x8C, 0x34, 0x20, 0x0B, 0x2A, 0x38, 0x89, 0x20, 0xF9, 0x73, 0x25, - 0x1B, 0x3C, 0x0E, 0xA1, 0x46, 0x8F, 0x98, 0x9E, 0x79, 0x7A, 0xCF, 0x31, 0xBE, 0xBB, 0x8B, 0x0D, - 0xDB, 0x4E, 0x97, 0x7C, 0x53, 0x8F, 0x78, 0x0A, 0x81, 0x32, 0x80, 0x8A, 0xD6, 0x46, 0x50, 0x31, - 0x4F, 0x11, 0x84, 0x7C, 0x8A, 0xFF, 0x05, 0x7A, 0x30, 0x7D, 0x36, 0xA4, 0x8B, 0x4C, 0x4D, 0x65, - 0x3E, 0xE5, 0x0B, 0x58, 0xF9, 0x3D, 0x44, 0x91, 0x6C, 0x49, 0x5B, 0x33, 0x3A, 0xB9, 0xEC, 0x74, - 0x90, 0x1B, 0x10, 0xB6, 0x10, 0x27, 0x5A, 0x5B, 0xC5, 0xA7, 0xCB, 0xAC, 0xCB, 0x00, 0x46, 0x05, - 0x44, 0xC1, 0x82, 0x0D, 0x38, 0x1D, 0x46, 0x79, 0x55, 0xAD, 0x48, 0x11, 0x9B, 0x14, 0x91, 0x99, - 0x3C, 0xA8, 0xAA, 0x85, 0x8E, 0x03, 0x14, 0x09, 0x58, 0x38, 0x50, 0x69, 0xFA, 0x1E, 0x3C, 0xDA, - 0x19, 0x75, 0x94, 0x31, 0x7A, 0x40, 0x6E, 0x81, 0x33, 0x09, 0xA8, 0x66, 0xC2, 0x38, 0x76, 0x30, - 0x1D, 0xBC, 0xD4, 0xA6, 0x22, 0x81, 0x8A, 0x69, 0xA4, 0x6A, 0x0C, 0x77, 0xA2, 0x43, 0x40, 0xC8, - 0x59, 0x06, 0x8F, 0x11, 0x36, 0x50, 0x92, 0x81, 0x86, 0x1F, 0x00, 0xC0, 0xA0, 0x11, 0xC1, 0xF1, - 0x77, 0x25, 0x43, 0x8B, 0x3D, 0x6C, 0xCC, 0xBA, 0xFA, 0x14, 0xEC, 0x75, 0xB5, 0x6E, 0x76, 0xBE, - 0xEB, 0x77, 0xEE, 0xD9, 0x5F, 0xFD, 0x6A, 0x00, 0x6C, 0x82, 0x03, 0x15, 0x2E, 0xB8, 0xFA, 0xB0, - 0x09, 0x93, 0x32, 0x19, 0xA7, 0x85, 0xFF, 0xFB, 0x92, 0x64, 0xA4, 0x80, 0x82, 0x74, 0x25, 0x44, - 0xCB, 0x26, 0x1A, 0x20, 0x4B, 0x24, 0x48, 0x92, 0x18, 0x22, 0xC2, 0x0B, 0xD4, 0x6F, 0x0F, 0x2C, - 0xBC, 0x65, 0x01, 0x04, 0x8A, 0xE2, 0xA0, 0x60, 0x8C, 0xE0, 0x81, 0xC8, 0x13, 0x71, 0xF3, 0xB8, - 0xB8, 0x08, 0x36, 0xC0, 0xA8, 0x08, 0x99, 0x9D, 0xAE, 0x2F, 0x8C, 0x48, 0x84, 0x2A, 0xB2, 0x8F, - 0xF4, 0x2E, 0x91, 0x0C, 0x16, 0x3A, 0xEA, 0x0A, 0xE9, 0xBB, 0xBC, 0x8D, 0x5F, 0xE4, 0x56, 0xB1, - 0x95, 0xCD, 0x2C, 0xC2, 0x1A, 0x58, 0x30, 0x72, 0x80, 0xB1, 0x16, 0x56, 0x84, 0xEE, 0x12, 0x5C, - 0xF6, 0x09, 0x7A, 0x8A, 0xAF, 0x5D, 0x97, 0xB4, 0x75, 0x1B, 0xCF, 0xEA, 0x50, 0x20, 0x25, 0x72, - 0x1B, 0x26, 0xF5, 0x52, 0x4C, 0x3C, 0x94, 0xD2, 0x02, 0x08, 0xBF, 0xB3, 0xD0, 0x3B, 0x6A, 0x13, - 0xC3, 0x6B, 0x77, 0x6F, 0x2D, 0xFE, 0x67, 0xBD, 0x7D, 0xC8, 0x70, 0x7C, 0x63, 0x19, 0x8E, 0xCF, - 0x53, 0xDE, 0x2D, 0x39, 0x4B, 0x76, 0x92, 0x1A, 0x03, 0x03, 0xB2, 0x36, 0xA4, 0x93, 0xBA, 0x4C, - 0xB8, 0x0C, 0x94, 0x66, 0x66, 0x15, 0x59, 0x28, 0x83, 0xFE, 0x17, 0x5F, 0xDF, 0xDB, 0xD3, 0x39, - 0xDA, 0xB5, 0x13, 0x68, 0x90, 0x9E, 0x1F, 0xAA, 0x45, 0x81, 0x05, 0xD0, 0x19, 0x62, 0x61, 0xC9, - 0x29, 0x89, 0xD2, 0x20, 0xAE, 0x44, 0x60, 0x99, 0xA3, 0x53, 0x55, 0xD6, 0x13, 0xC3, 0x02, 0x30, - 0x4F, 0xB5, 0x76, 0xE1, 0x17, 0xE2, 0xD4, 0xBA, 0xA6, 0x9A, 0x82, 0x04, 0x88, 0x1C, 0xF1, 0xDE, - 0x3C, 0x48, 0xAF, 0xE6, 0x8D, 0x19, 0x11, 0x68, 0xA2, 0xC8, 0xF3, 0xFA, 0xD3, 0xCC, 0x9E, 0x5D, - 0xFD, 0xBE, 0x30, 0x73, 0x69, 0x3F, 0x3F, 0xC1, 0xC9, 0xC0, 0x20, 0xF3, 0xC4, 0xF6, 0xD4, 0xC3, - 0xE8, 0x68, 0xE4, 0x97, 0x75, 0x83, 0xC9, 0x29, 0xB7, 0x99, 0x63, 0xB3, 0x03, 0x08, 0x0A, 0x20, - 0x00, 0x89, 0xE7, 0x19, 0xB8, 0x19, 0xB2, 0x3E, 0x45, 0x40, 0x08, 0xD5, 0xFE, 0xD5, 0x62, 0x5D, - 0xD3, 0x1F, 0xE9, 0x34, 0x79, 0x78, 0xF5, 0xE4, 0xEE, 0xAF, 0x19, 0x95, 0x55, 0xB9, 0x11, 0x49, - 0xCC, 0x19, 0x6C, 0x56, 0xDC, 0xEB, 0x3C, 0x32, 0xF3, 0x67, 0xDA, 0xBF, 0x91, 0xAB, 0x77, 0x13, - 0xE8, 0xB7, 0x6B, 0x31, 0x8E, 0x3B, 0xD4, 0x7D, 0xD8, 0xE1, 0xAD, 0xAA, 0x7B, 0xBB, 0x60, 0x98, - 0xD6, 0xDD, 0xBC, 0xD9, 0x74, 0xDF, 0xFF, 0x6F, 0xAB, 0x1D, 0x51, 0xBD, 0x43, 0xE1, 0xF4, 0x9D, - 0xD2, 0x10, 0xD7, 0x7F, 0xDD, 0x9A, 0xD0, 0x30, 0x2C, 0xE1, 0x00, 0x05, 0x00, 0x8C, 0x4D, 0x85, - 0x20, 0x8B, 0x03, 0x50, 0x82, 0x03, 0xC5, 0xB6, 0x93, 0x39, 0xC1, 0xD7, 0x72, 0xAD, 0x2C, 0xC3, - 0x34, 0x42, 0xD8, 0xF7, 0x8D, 0x64, 0xA4, 0x86, 0x32, 0x9B, 0xB2, 0x85, 0x8B, 0x34, 0x2D, 0xE6, - 0xD8, 0x3A, 0xB8, 0x77, 0xA7, 0x9F, 0x92, 0x52, 0xD2, 0xCC, 0x98, 0xFD, 0x9E, 0x9A, 0x69, 0xE5, - 0x0E, 0x02, 0xA4, 0x72, 0xE9, 0x6F, 0xFF, 0x38, 0xFF, 0xFB, 0x92, 0x64, 0xC6, 0x88, 0x02, 0xE7, - 0x2A, 0xC3, 0x33, 0x48, 0x12, 0xE0, 0x40, 0x65, 0x68, 0xC9, 0x18, 0x23, 0xC4, 0x4C, 0x24, 0xD7, - 0x0C, 0x4D, 0x18, 0x6A, 0x41, 0x30, 0x93, 0x63, 0x64, 0x60, 0x8F, 0x41, 0x85, 0x0E, 0x3F, 0x3E, - 0x7E, 0xCA, 0x61, 0xE5, 0xFC, 0x84, 0xC8, 0xCB, 0x9A, 0x63, 0x05, 0xBB, 0xB8, 0x8A, 0xFB, 0xA6, - 0xFF, 0xD6, 0xB5, 0xFB, 0x0E, 0xF6, 0x73, 0x77, 0x3B, 0xC5, 0xBD, 0x97, 0x31, 0xA5, 0xDE, 0xC8, - 0x01, 0xC2, 0xE5, 0xDB, 0x3B, 0x63, 0x45, 0x08, 0xC9, 0x41, 0x01, 0x65, 0x13, 0x51, 0x27, 0xB5, - 0x56, 0xA4, 0xCE, 0xCA, 0xD1, 0x2F, 0xC9, 0xF6, 0x97, 0x0F, 0x7B, 0x91, 0x8A, 0x40, 0xEC, 0xA2, - 0x47, 0x3A, 0xB7, 0x20, 0x4F, 0x6E, 0xBD, 0x48, 0x14, 0x83, 0x94, 0x15, 0x00, 0x5A, 0xEA, 0x8F, - 0x0A, 0x2D, 0x51, 0xF9, 0xC4, 0xB5, 0x91, 0x7D, 0x52, 0x1F, 0x42, 0x2F, 0x72, 0xFB, 0xD6, 0x21, - 0x52, 0x00, 0x8C, 0x0A, 0x58, 0x38, 0x77, 0x80, 0xAB, 0x93, 0xAF, 0x31, 0x36, 0x5C, 0x99, 0x2A, - 0x77, 0xBC, 0xB2, 0xA5, 0x3D, 0x10, 0xC7, 0x10, 0x4D, 0x24, 0xBA, 0xFD, 0x8A, 0x92, 0xE5, 0x01, - 0x24, 0x9D, 0xB4, 0x89, 0x37, 0x5A, 0x10, 0x69, 0x8E, 0x6C, 0xFA, 0xAA, 0x09, 0x03, 0x1B, 0xE7, - 0xD7, 0xDB, 0x23, 0xC7, 0xFC, 0x8D, 0xDC, 0x8B, 0xE0, 0xCA, 0x09, 0x0B, 0xD7, 0xFE, 0x4E, 0x5C, - 0xC9, 0xD4, 0x88, 0x92, 0xB4, 0xFD, 0x4F, 0xE7, 0xDB, 0xB4, 0x04, 0xB7, 0xCE, 0x04, 0x27, 0x85, - 0xE9, 0x92, 0x16, 0x07, 0xF3, 0x5C, 0xF4, 0x3F, 0xFD, 0xFF, 0x04, 0x6B, 0xF7, 0xE4, 0x8B, 0xF0, - 0x68, 0x75, 0x66, 0xD7, 0xC7, 0x45, 0x75, 0xAA, 0xE0, 0x05, 0xFA, 0x05, 0xDA, 0x07, 0xB9, 0x0C, - 0x2F, 0x60, 0x07, 0x1E, 0xA4, 0x23, 0x08, 0x1A, 0xC5, 0x3D, 0x07, 0xBA, 0x30, 0x8F, 0x6D, 0x47, - 0xC5, 0x53, 0x62, 0x0F, 0xFE, 0xF9, 0x79, 0xE1, 0x1F, 0x9F, 0xD5, 0x7F, 0x6F, 0xBB, 0xC3, 0xF8, - 0x29, 0x0B, 0x37, 0x2B, 0xE5, 0x8E, 0x43, 0x26, 0xA7, 0x13, 0x4C, 0x17, 0x48, 0x9D, 0x20, 0x26, - 0x0C, 0x07, 0x4A, 0xB0, 0x60, 0x91, 0x02, 0x60, 0x09, 0xF8, 0x2C, 0xA7, 0x98, 0x61, 0x06, 0x08, - 0x6E, 0xAC, 0x22, 0xD0, 0xEE, 0x2A, 0xF7, 0xED, 0xF3, 0x5B, 0x2F, 0x74, 0xC6, 0xFD, 0xFD, 0xD5, - 0x02, 0x39, 0x0B, 0x39, 0x1C, 0x60, 0x6A, 0xCA, 0xB0, 0x23, 0xE0, 0x5E, 0x1D, 0x3B, 0x2B, 0x14, - 0x05, 0xAB, 0x86, 0xCA, 0x93, 0x2A, 0x65, 0xBB, 0x7A, 0xC5, 0xF7, 0xE1, 0x44, 0x44, 0x11, 0x85, - 0x35, 0x42, 0x04, 0x60, 0xDF, 0x23, 0x33, 0xAF, 0x95, 0x8F, 0xED, 0x3C, 0xA7, 0x1C, 0xDF, 0xCB, - 0x7C, 0x4B, 0x0B, 0x43, 0xC1, 0xE7, 0x8B, 0x96, 0x1E, 0x4C, 0x40, 0x16, 0x22, 0xF3, 0x27, 0x1C, - 0xD2, 0x57, 0xD3, 0x83, 0x69, 0x6C, 0xFD, 0xC2, 0x33, 0x4A, 0x2A, 0x58, 0xB4, 0x22, 0x51, 0xD7, - 0x0A, 0xC3, 0x29, 0xD2, 0xA7, 0xDA, 0xE6, 0x89, 0x06, 0xB1, 0xFF, 0xFB, 0x92, 0x64, 0xE0, 0x08, - 0x03, 0x2D, 0x42, 0x42, 0x83, 0x78, 0x19, 0x42, 0x3F, 0x45, 0x09, 0x4D, 0x00, 0x23, 0x0D, 0x0D, - 0x81, 0x03, 0x0D, 0x2D, 0x18, 0x6D, 0x49, 0x52, 0x13, 0xE2, 0x54, 0xC1, 0x98, 0x58, 0x48, 0x2C, - 0xB5, 0x12, 0x42, 0xA7, 0xB6, 0x00, 0x2A, 0x0D, 0x42, 0x80, 0x8C, 0x44, 0x5E, 0x32, 0x01, 0x4A, - 0x26, 0xC7, 0xAE, 0x68, 0xD4, 0xA6, 0xAA, 0x99, 0xCA, 0x9E, 0xCD, 0x52, 0x13, 0x55, 0x92, 0xE6, - 0xA8, 0x49, 0xE4, 0xCB, 0x55, 0x15, 0x74, 0x4F, 0x69, 0x2F, 0xED, 0x4A, 0x0B, 0x37, 0x13, 0x86, - 0x0A, 0x3B, 0x02, 0x54, 0x86, 0xA6, 0x59, 0x92, 0xF4, 0x41, 0x6B, 0x84, 0x0E, 0x15, 0x11, 0x30, - 0x00, 0x0B, 0x90, 0x32, 0x22, 0x7A, 0x98, 0x5E, 0x91, 0x61, 0x7A, 0x42, 0xEF, 0x01, 0x9E, 0x5C, - 0x9D, 0x8A, 0x15, 0xC9, 0xEF, 0x68, 0xC2, 0xAD, 0x16, 0x7A, 0x0F, 0xD6, 0xDF, 0xDD, 0xFA, 0x10, - 0x03, 0x42, 0x64, 0x42, 0x40, 0x5F, 0x50, 0xD3, 0x23, 0xF6, 0x95, 0x1A, 0xA1, 0xB6, 0xF8, 0x18, - 0x32, 0x95, 0x73, 0xB0, 0xF6, 0x46, 0xA6, 0xEE, 0x18, 0x08, 0x1A, 0xD7, 0xE8, 0x08, 0x2E, 0x61, - 0x11, 0x56, 0x38, 0xBA, 0x91, 0x45, 0x18, 0x74, 0x40, 0x08, 0x43, 0x8F, 0x67, 0x62, 0x21, 0x1C, - 0xEA, 0xC2, 0x42, 0x81, 0xF3, 0x44, 0xC0, 0x81, 0xFC, 0xE2, 0xF4, 0x31, 0x00, 0x08, 0xA2, 0x3B, - 0x11, 0xDE, 0x87, 0xAA, 0x94, 0x8F, 0x2C, 0x85, 0x47, 0x1C, 0xAE, 0x1C, 0x14, 0x63, 0x10, 0xA7, - 0x32, 0x24, 0x84, 0x55, 0x2B, 0xE8, 0x8F, 0xE7, 0x62, 0x36, 0x8D, 0x74, 0x6B, 0x6E, 0xEA, 0x8E, - 0xAC, 0x55, 0x76, 0xD6, 0x46, 0x7A, 0xD2, 0x8A, 0xB6, 0xAD, 0x95, 0x7A, 0xA9, 0x84, 0x9D, 0x7F, - 0x5B, 0x9B, 0xAF, 0x14, 0x6C, 0x42, 0x76, 0xFD, 0x52, 0x00, 0x11, 0x5A, 0x22, 0xAC, 0x58, 0xC3, - 0x58, 0x24, 0x69, 0xFC, 0x95, 0x43, 0x9E, 0x4E, 0x9B, 0xBB, 0x14, 0x88, 0x28, 0x2A, 0x84, 0x14, - 0x30, 0x68, 0x22, 0x0A, 0x18, 0xC6, 0x47, 0x2E, 0x71, 0x73, 0x22, 0x14, 0x85, 0x10, 0x6A, 0x98, - 0x72, 0x23, 0x36, 0xA7, 0xE8, 0xAC, 0x6B, 0x3A, 0x51, 0x48, 0x75, 0x66, 0xDD, 0x2E, 0xAF, 0x55, - 0x57, 0x42, 0xB8, 0xBB, 0xB1, 0x9D, 0xD9, 0xBB, 0x9D, 0x7D, 0x9A, 0x46, 0x61, 0xBD, 0x7F, 0x5E, - 0xF5, 0xF9, 0xC3, 0x96, 0xEC, 0xDC, 0xAA, 0x81, 0xC4, 0xFD, 0xDB, 0xD1, 0xAF, 0xA3, 0xAA, 0x00, - 0x00, 0x01, 0x00, 0x00, 0x01, 0x40, 0xCF, 0x0F, 0x0C, 0x60, 0x70, 0xA8, 0xD4, 0x60, 0xCE, 0x67, - 0xAB, 0xBA, 0x30, 0x9C, 0x06, 0x0F, 0x6E, 0x26, 0x22, 0x42, 0x1C, 0x30, 0x70, 0xCE, 0x47, 0x59, - 0x24, 0xFB, 0xA3, 0x1A, 0x09, 0x01, 0xC0, 0xA6, 0x64, 0x22, 0x65, 0xA4, 0x30, 0xA8, 0x0E, 0x2B, - 0x58, 0xEB, 0x4C, 0x02, 0x8D, 0xAB, 0xF0, 0xC3, 0x14, 0x54, 0x8B, 0x89, 0x45, 0x93, 0x2C, 0x08, - 0x64, 0x0B, 0x1A, 0x9D, 0x93, 0x22, 0x22, 0x26, 0x34, 0x28, 0x10, 0x48, 0xFF, 0xFB, 0x92, 0x64, - 0xEC, 0x09, 0x03, 0x09, 0x25, 0x43, 0xAB, 0x4C, 0x19, 0x50, 0x5A, 0x25, 0x48, 0xA9, 0x30, 0xC3, - 0x4E, 0x0F, 0x35, 0x89, 0x0C, 0xB5, 0xA2, 0x80, 0x09, 0x56, 0x1E, 0xE3, 0x26, 0x8C, 0x50, 0x01, - 0x57, 0xA9, 0x04, 0x21, 0x81, 0xD4, 0x70, 0x25, 0x12, 0xD7, 0xFD, 0xD7, 0x4E, 0x77, 0xDC, 0xBE, - 0xA9, 0xC6, 0xA9, 0xC4, 0x8B, 0x41, 0x32, 0x61, 0xC5, 0xAB, 0x34, 0xF9, 0xCC, 0x73, 0xDB, 0x4C, - 0x5F, 0x4F, 0xAD, 0xBC, 0xAB, 0x8D, 0x16, 0x32, 0x12, 0xEE, 0x77, 0x29, 0x98, 0x05, 0x36, 0x5A, - 0x9F, 0x91, 0xC3, 0x73, 0x5D, 0x9A, 0xB1, 0x03, 0x3E, 0xAC, 0x81, 0x87, 0xC2, 0x28, 0x15, 0x58, - 0x98, 0x81, 0xA1, 0x88, 0x8D, 0x57, 0xD4, 0xF9, 0xCB, 0xF0, 0xD6, 0xBF, 0x2F, 0x78, 0xE4, 0x54, - 0x9F, 0xAE, 0x6F, 0x9C, 0x6F, 0x9B, 0xEB, 0xDF, 0xBF, 0xD7, 0x79, 0xF8, 0x61, 0xFC, 0xDF, 0x7F, - 0x99, 0x6E, 0xF7, 0xE1, 0xAF, 0xDE, 0x1F, 0x6F, 0x3A, 0xFF, 0x8E, 0x1C, 0xFF, 0xCB, 0xF5, 0x97, - 0xDD, 0x62, 0x61, 0xC0, 0x90, 0x40, 0x2E, 0x90, 0x18, 0x3E, 0x22, 0x22, 0x71, 0x4C, 0x0B, 0xD8, - 0x90, 0xB3, 0xCE, 0xA3, 0xFF, 0xE4, 0xC0, 0x21, 0x40, 0x20, 0x62, 0x00, 0x00, 0x00, 0x00, 0x12, - 0xA3, 0x4C, 0x7F, 0x0F, 0x61, 0x5D, 0xEB, 0x71, 0x01, 0x16, 0x5C, 0x99, 0xD5, 0x0A, 0xF5, 0x7B, - 0x35, 0x17, 0x28, 0xCA, 0xA9, 0x61, 0x7F, 0x48, 0x1A, 0x43, 0x64, 0x84, 0x72, 0xFB, 0xE7, 0xA4, - 0x7D, 0x43, 0xAD, 0x61, 0x25, 0x9A, 0x23, 0x82, 0xA9, 0xED, 0x15, 0x56, 0x10, 0xD9, 0xBA, 0x0B, - 0xEB, 0x2F, 0x59, 0xED, 0xD5, 0x79, 0x07, 0x5F, 0xE9, 0x37, 0x9C, 0x86, 0xAD, 0xFB, 0x23, 0x8A, - 0xAB, 0x7F, 0x21, 0x2C, 0x98, 0xAF, 0xF1, 0x30, 0xFC, 0x5D, 0x98, 0xDE, 0x39, 0x19, 0xDD, 0xA3, - 0x5C, 0xC2, 0xBF, 0xD6, 0x1E, 0xA4, 0x6B, 0x50, 0xA9, 0x2C, 0x5E, 0x7B, 0xFF, 0x37, 0x6F, 0x14, - 0x78, 0xFE, 0xC5, 0x3B, 0xFF, 0x34, 0xCF, 0xCB, 0x74, 0xCD, 0x6D, 0x37, 0xD8, 0xFE, 0x9B, 0x6C, - 0x9B, 0xFD, 0x6B, 0x39, 0x99, 0xFD, 0x6D, 0xBD, 0xF2, 0x7F, 0x35, 0x94, 0x31, 0x43, 0x13, 0x36, - 0x64, 0x62, 0xD6, 0xDB, 0x0D, 0xFF, 0xFE, 0xFF, 0xFF, 0xD8, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x80, 0x92, 0x19, 0x60, 0x24, 0x18, 0xFC, 0x77, 0x18, 0xBE, 0x99, 0x99, 0x50, - 0x7E, 0x98, 0x7E, 0xF4, 0x9C, 0xD4, 0xD5, 0x98, 0x64, 0x35, 0x91, 0x3B, 0x06, 0x3F, 0x0A, 0x26, - 0x10, 0x90, 0x47, 0xB8, 0x73, 0x86, 0xEC, 0x9B, 0x26, 0x2A, 0x92, 0x66, 0x18, 0x82, 0x86, 0x44, - 0x0B, 0x86, 0x38, 0x02, 0x26, 0x55, 0x19, 0x80, 0xA1, 0x74, 0xD0, 0xC6, 0x8B, 0x7A, 0x23, 0x01, - 0x30, 0x30, 0x33, 0x1F, 0x12, 0x03, 0x01, 0xB6, 0x76, 0xE8, 0xAA, 0xE8, 0xD0, 0x9E, 0xC9, 0x08, - 0xD3, 0x66, 0x5E, 0x24, 0xD7, 0x4A, 0xD6, 0x15, 0x10, 0x30, 0x61, 0x53, 0x1A, 0x02, 0xFF, 0xFB, - 0x92, 0x64, 0xE5, 0x80, 0x06, 0x9A, 0x50, 0x44, 0x26, 0x6F, 0x20, 0x00, 0x93, 0xAA, 0xF8, 0xA9, - 0xC7, 0xB0, 0x00, 0x1A, 0x80, 0xF1, 0x27, 0x59, 0xDD, 0x80, 0x02, 0x48, 0x1D, 0xE3, 0x8B, 0x35, - 0x80, 0x00, 0x04, 0x81, 0xA3, 0xE0, 0xAA, 0x09, 0xD2, 0x0A, 0x96, 0x88, 0x0C, 0x34, 0xB4, 0x1C, - 0x95, 0x6C, 0x5A, 0x8F, 0xA2, 0x57, 0x83, 0x05, 0x80, 0x40, 0x01, 0x81, 0x05, 0xA0, 0x2D, 0x08, - 0xD4, 0x99, 0x96, 0x10, 0x81, 0x83, 0x5A, 0xDA, 0x07, 0xA3, 0x44, 0x3D, 0x33, 0x1F, 0x75, 0xD0, - 0xC9, 0x5B, 0x51, 0xED, 0x6F, 0x35, 0xB5, 0xBC, 0x60, 0x62, 0x04, 0xC2, 0xCD, 0x89, 0x7E, 0xB6, - 0x59, 0x1F, 0xFE, 0x95, 0x81, 0x86, 0x33, 0x38, 0xE7, 0x77, 0x71, 0x84, 0x43, 0x70, 0x4B, 0x36, - 0xDE, 0xB6, 0xB2, 0xB4, 0xD9, 0x29, 0x58, 0x14, 0x83, 0xFF, 0xFF, 0xFF, 0xD3, 0x57, 0xF9, 0xFF, - 0xFF, 0xFE, 0x58, 0x06, 0x8A, 0x73, 0xED, 0x5F, 0xFF, 0xEC, 0x7B, 0x5F, 0xF6, 0xA5, 0x32, 0x43, - 0x7B, 0x15, 0x00, 0x00, 0x00, 0x02, 0x08, 0x0C, 0x4B, 0x72, 0xA9, 0x01, 0xFA, 0x23, 0x00, 0x41, - 0x08, 0x02, 0x05, 0xA4, 0x81, 0x12, 0x67, 0x58, 0xEB, 0xEE, 0x35, 0x42, 0x1D, 0x86, 0x80, 0x60, - 0x8C, 0x15, 0x47, 0xAB, 0xD3, 0x2C, 0x65, 0xF8, 0xC5, 0x62, 0xDF, 0x81, 0x2E, 0x72, 0x6A, 0x8F, - 0x3B, 0x0C, 0x6E, 0x51, 0x4C, 0xAA, 0xB2, 0x87, 0xF3, 0x72, 0xC2, 0xFD, 0xA6, 0x4B, 0x13, 0x34, - 0x8C, 0x60, 0x6B, 0x44, 0x00, 0x3F, 0x7E, 0xFF, 0x7F, 0xEF, 0xD4, 0x37, 0x3E, 0xAE, 0xED, 0xB6, - 0x55, 0x2B, 0x2E, 0xF0, 0x61, 0x9D, 0x0C, 0x21, 0xC9, 0xB8, 0x54, 0xC4, 0x19, 0x2F, 0x76, 0xA6, - 0xE6, 0x33, 0xA7, 0x4B, 0xC7, 0x3E, 0x9E, 0xD3, 0xF7, 0x6E, 0x8B, 0xF2, 0x99, 0xBB, 0xCB, 0xF6, - 0x7B, 0xFF, 0xCC, 0x59, 0xE6, 0x5F, 0xAE, 0x4D, 0x3E, 0x50, 0xFC, 0xBF, 0xFF, 0xFF, 0xFF, 0xFD, - 0xA9, 0x67, 0xFD, 0xDF, 0xFF, 0xE3, 0x2B, 0xB4, 0x14, 0x4E, 0xF6, 0xD4, 0xEC, 0xA9, 0xE3, 0xDE, - 0x7E, 0xAF, 0xFF, 0xD5, 0x30, 0x08, 0x4B, 0x33, 0x08, 0x64, 0x33, 0x1C, 0x54, 0x34, 0x95, 0xE9, - 0x32, 0x10, 0xA7, 0x33, 0x21, 0x88, 0x04, 0xF1, 0x47, 0x79, 0x10, 0x66, 0x36, 0x4E, 0x06, 0xD9, - 0x8B, 0xC6, 0x32, 0xA1, 0xC2, 0x33, 0x88, 0xCD, 0xE3, 0xAC, 0xC1, 0x92, 0xC0, 0xCC, 0xA1, 0x24, - 0xC4, 0x80, 0x38, 0xC3, 0x10, 0x39, 0x38, 0xA5, 0x4A, 0xAF, 0x04, 0xBB, 0x4E, 0x53, 0xC3, 0x52, - 0xEE, 0xFF, 0xBA, 0xEF, 0x26, 0x5A, 0x30, 0xB0, 0xCF, 0x0D, 0x08, 0x79, 0xE4, 0x0A, 0xB0, 0x60, - 0x22, 0x56, 0x47, 0xF6, 0x92, 0xF0, 0x5A, 0x0A, 0x00, 0x71, 0xC2, 0x87, 0x70, 0x4F, 0xE5, 0x71, - 0xCC, 0x66, 0x36, 0x9C, 0x50, 0x23, 0xD9, 0x7B, 0xCB, 0x3E, 0x80, 0x36, 0x83, 0x0C, 0x25, 0xE1, - 0xA8, 0xCF, 0xD1, 0x7D, 0xA4, 0xF2, 0x2B, 0x93, 0xD8, 0x38, 0xD0, 0x4B, 0x4F, 0xB7, 0xCA, 0x5B, - 0xFF, 0xFB, 0x92, 0x64, 0x3E, 0x0B, 0x04, 0xCA, 0x34, 0xCA, 0x07, 0x77, 0x00, 0x00, 0x30, 0x83, - 0x59, 0xDD, 0xE0, 0xA0, 0x00, 0x93, 0x2C, 0xD3, 0x29, 0x0F, 0x73, 0x26, 0x80, 0xC5, 0x98, 0xA7, - 0x74, 0x21, 0x8A, 0x0A, 0x36, 0xBF, 0xFF, 0xFF, 0xFF, 0xF0, 0xB8, 0xF4, 0xED, 0x9E, 0x2C, 0x1B, - 0x5E, 0x93, 0x48, 0x91, 0x09, 0x94, 0x3F, 0x0B, 0xE1, 0x72, 0xBC, 0x4C, 0x31, 0xDA, 0x84, 0xC3, - 0x96, 0x0A, 0x84, 0x82, 0x8A, 0xA4, 0x00, 0x01, 0x10, 0x21, 0xB8, 0x85, 0x13, 0xD8, 0x98, 0xD8, - 0x0B, 0x56, 0xE6, 0x19, 0xC6, 0xA8, 0x7E, 0x3D, 0x79, 0x53, 0x4D, 0x05, 0x06, 0xED, 0x3F, 0xF6, - 0xBA, 0xB6, 0xA4, 0xAF, 0x83, 0x7A, 0x93, 0xFF, 0x28, 0xE2, 0xF5, 0x53, 0xFF, 0xFF, 0xF9, 0x75, - 0xF6, 0xBC, 0x09, 0x0C, 0x01, 0x23, 0x04, 0x22, 0x1A, 0x30, 0x36, 0x06, 0x23, 0x19, 0xA1, 0x7A, - 0x30, 0x5B, 0x06, 0x43, 0x0C, 0x22, 0x29, 0x30, 0x0A, 0x42, 0x63, 0x20, 0x21, 0x99, 0x34, 0x12, - 0x08, 0xEC, 0x65, 0x23, 0x1D, 0x85, 0x8D, 0x50, 0x4A, 0x3E, 0xF9, 0x34, 0xD5, 0x00, 0x13, 0x0B, - 0x8C, 0x49, 0x81, 0x21, 0x5A, 0x33, 0x3D, 0x75, 0x8F, 0x65, 0x6E, 0x7B, 0x79, 0xF7, 0xF7, 0xCF, - 0xF9, 0x96, 0xE8, 0xB2, 0xD8, 0x79, 0x94, 0x79, 0xBE, 0xF1, 0xC9, 0x32, 0x01, 0x41, 0xD2, 0x49, - 0x2E, 0x3B, 0x96, 0x4B, 0x64, 0x0E, 0x30, 0x75, 0x01, 0x96, 0x4D, 0x92, 0x83, 0x8B, 0x1E, 0x0C, - 0x10, 0x09, 0x72, 0x8A, 0x88, 0x3B, 0xE0, 0x52, 0x11, 0x68, 0xA1, 0xC5, 0xCA, 0x8F, 0xE9, 0xF6, - 0xD0, 0x15, 0x5E, 0x82, 0x9B, 0xF5, 0x62, 0x32, 0xCC, 0xD7, 0x7D, 0xBB, 0x1F, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFA, 0xCD, 0x91, 0x97, 0xC6, 0x91, 0x8D, 0xBA, 0x88, 0x50, 0x86, 0x2C, 0x12, 0xDB, 0x27, - 0x69, 0xD9, 0xA1, 0xB4, 0x6D, 0x3E, 0x20, 0x14, 0x2D, 0x80, 0xEF, 0x05, 0x00, 0x80, 0x17, 0x88, - 0x00, 0x84, 0x20, 0x06, 0xE6, 0x99, 0xFD, 0x57, 0x51, 0xF0, 0x49, 0x87, 0x26, 0x60, 0x6D, 0x63, - 0xF4, 0x02, 0x06, 0x1C, 0xF4, 0x4E, 0x77, 0xA7, 0x53, 0xB7, 0x4C, 0xEF, 0xFD, 0xFF, 0xFF, 0x52, - 0x9C, 0x8B, 0x93, 0x38, 0x49, 0x33, 0x86, 0x7F, 0xFF, 0xFE, 0xAD, 0x9E, 0x85, 0x00, 0x40, 0x00, - 0x00, 0x05, 0xCC, 0x25, 0xC6, 0x28, 0xC5, 0x20, 0x0C, 0xCC, 0x70, 0x49, 0x28, 0xC2, 0x40, 0x2C, - 0xCC, 0x78, 0xCA, 0x18, 0xC1, 0xF5, 0x0B, 0x88, 0xA6, 0xE8, 0xC1, 0xE7, 0xE3, 0x88, 0x0E, 0x8C, - 0xB2, 0x01, 0x37, 0xF1, 0xE4, 0xDE, 0x8E, 0x10, 0x40, 0x98, 0x28, 0x87, 0x31, 0xA4, 0xCC, 0xBB, - 0x16, 0xB8, 0xB6, 0x9F, 0x79, 0x3C, 0xDC, 0x16, 0xD4, 0xF7, 0x43, 0x9D, 0x8E, 0x7F, 0xFE, 0x11, - 0xE1, 0xD0, 0xAB, 0x0E, 0x62, 0xBF, 0x14, 0xBA, 0x31, 0x81, 0x45, 0x82, 0x99, 0x90, 0x66, 0x0C, - 0x2B, 0x76, 0x6C, 0xC5, 0xEA, 0x61, 0x82, 0xC6, 0x4C, 0x58, 0x23, 0x28, 0x2C, 0xC6, 0xCB, 0x31, - 0x63, 0x8A, 0xFF, 0xFB, 0x92, 0x64, 0x32, 0x8B, 0x95, 0x27, 0x34, 0xC9, 0xAB, 0xDC, 0xD1, 0xA0, - 0x2E, 0x23, 0xD9, 0xBE, 0x08, 0x26, 0x0E, 0x16, 0x68, 0xD3, 0x20, 0x0F, 0x6F, 0x49, 0xC0, 0xAA, - 0x91, 0x66, 0x50, 0x60, 0x18, 0x1A, 0x11, 0x08, 0x81, 0x0F, 0x44, 0x11, 0x05, 0x1E, 0x9C, 0xD0, - 0x52, 0xF8, 0x64, 0x41, 0x65, 0x8C, 0x10, 0xC0, 0xB8, 0x35, 0x38, 0x5A, 0x11, 0x7B, 0x3A, 0xEB, - 0x2F, 0x61, 0x2D, 0xCD, 0x52, 0xCA, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xB4, 0xDE, 0x34, - 0xC5, 0x8C, 0xD0, 0x96, 0x6A, 0xC3, 0x91, 0x11, 0x4F, 0xD7, 0xF1, 0x45, 0x67, 0xDC, 0x16, 0xE8, - 0xE3, 0x2E, 0x47, 0xB9, 0x97, 0x62, 0x0A, 0x00, 0x04, 0x00, 0x0F, 0x10, 0x00, 0x00, 0x00, 0xEB, - 0xFC, 0xC7, 0x31, 0x4E, 0x94, 0x26, 0x8B, 0x4E, 0xAF, 0xE7, 0xFE, 0x49, 0x98, 0x2C, 0x79, 0xF9, - 0x6B, 0x7B, 0x9D, 0xC4, 0x0E, 0xC9, 0x88, 0x11, 0x13, 0x53, 0x6C, 0xA5, 0x06, 0x69, 0xFF, 0x82, - 0x94, 0xA8, 0x59, 0xCD, 0x30, 0x1E, 0x07, 0x53, 0x18, 0x72, 0xBF, 0x32, 0x40, 0x0F, 0x33, 0x10, - 0x96, 0x45, 0x31, 0x41, 0x11, 0x33, 0x54, 0x20, 0xCF, 0x30, 0x25, 0x29, 0x63, 0x2C, 0x11, 0xFC, - 0x30, 0x2B, 0x06, 0x83, 0x1F, 0x00, 0x41, 0x37, 0xCC, 0x90, 0x7D, 0xC1, 0xAB, 0xCA, 0x08, 0x87, - 0x0D, 0x57, 0x18, 0x1C, 0xAE, 0x22, 0x84, 0x12, 0x1D, 0x0C, 0x35, 0x4A, 0xD6, 0x09, 0x38, 0xD8, - 0x1E, 0x6D, 0x3E, 0x2C, 0x5D, 0x5B, 0xDB, 0x26, 0x5C, 0xFA, 0x09, 0x58, 0x50, 0x9D, 0x1E, 0x0C, - 0xBD, 0x08, 0xC6, 0x80, 0x06, 0xC2, 0x0C, 0x08, 0x5C, 0x2C, 0x18, 0x61, 0x83, 0x66, 0x5E, 0x14, - 0x61, 0x40, 0xA2, 0xC7, 0xC6, 0xE8, 0x9A, 0x5C, 0x98, 0x05, 0x65, 0x09, 0x0F, 0x43, 0x43, 0x0C, - 0x88, 0x16, 0x9C, 0x52, 0x01, 0xDF, 0x16, 0x0A, 0xD8, 0x6E, 0x54, 0x95, 0xAD, 0x10, 0x80, 0x24, - 0x18, 0x60, 0x85, 0x08, 0x93, 0xAB, 0xC4, 0xA9, 0x76, 0x98, 0x86, 0x1A, 0xA8, 0x8D, 0x20, 0x60, - 0xAB, 0x0E, 0xEE, 0xD3, 0x5F, 0xD7, 0xFF, 0xFF, 0xFF, 0xD4, 0x96, 0x57, 0x8E, 0x3F, 0x65, 0x40, - 0x2F, 0x2B, 0x2D, 0x6E, 0x25, 0xEE, 0x69, 0x05, 0xE9, 0x24, 0x07, 0x09, 0x60, 0x6F, 0x9A, 0xF0, - 0x54, 0x2B, 0xB6, 0xCA, 0x96, 0xC6, 0x68, 0x80, 0x09, 0x8E, 0xCE, 0xE4, 0x77, 0xBF, 0xAB, 0xCF, - 0xE8, 0x25, 0xE1, 0x50, 0x4F, 0xFF, 0xF4, 0xF3, 0x75, 0x5B, 0xF3, 0x09, 0xA2, 0xF3, 0x88, 0xEE, - 0x30, 0x2C, 0x12, 0x80, 0xCB, 0x9D, 0xE7, 0x7E, 0xDB, 0xFB, 0xAA, 0x77, 0xF8, 0x7A, 0xD5, 0x22, - 0x25, 0x30, 0x30, 0x03, 0x00, 0xB3, 0x00, 0xA4, 0x33, 0x07, 0x04, 0xC9, 0x9A, 0xD2, 0x28, 0x18, - 0xEE, 0x8B, 0x91, 0x94, 0x88, 0x45, 0x9A, 0x1D, 0x60, 0x16, 0xEC, 0xCA, 0x45, 0x4E, 0x96, 0x44, - 0xC1, 0x8B, 0x0F, 0x10, 0x84, 0xCC, 0x06, 0x32, 0x47, 0x4A, 0xA2, 0xCA, 0xA1, 0x08, 0x50, 0x82, - 0x9A, 0x86, 0x1A, 0x5B, 0xFF, 0xFB, 0x92, 0x64, 0x19, 0x0B, 0x15, 0x06, 0x34, 0xC9, 0x03, 0xDB, - 0xD1, 0x20, 0x2D, 0x86, 0x69, 0x46, 0x28, 0x6A, 0xB4, 0x51, 0xB4, 0xD3, 0x2A, 0xAF, 0x6F, 0x24, - 0x40, 0xBD, 0x9A, 0x65, 0x14, 0x74, 0x89, 0x18, 0xCD, 0x6A, 0xA2, 0xCB, 0xBD, 0x30, 0xF0, 0xBA, - 0x0D, 0xC4, 0x30, 0x04, 0x27, 0x7F, 0xCC, 0x87, 0x02, 0xA7, 0xCA, 0x08, 0x0C, 0x4C, 0x30, 0x70, - 0x54, 0xC5, 0x6B, 0xA9, 0xD4, 0x00, 0x02, 0x60, 0x04, 0xC7, 0xEF, 0xA9, 0xD1, 0x68, 0x05, 0x0A, - 0x84, 0x4A, 0x38, 0x70, 0x0C, 0x71, 0xC3, 0x0A, 0xDC, 0x28, 0x1C, 0xCC, 0x09, 0x33, 0x09, 0x44, - 0x64, 0x1F, 0xD2, 0xC9, 0x92, 0x05, 0x53, 0xB2, 0xD8, 0xA3, 0x9A, 0x46, 0x21, 0x05, 0x98, 0x62, - 0x20, 0x91, 0xC8, 0x0D, 0x56, 0xAE, 0xEF, 0x3E, 0x73, 0xFF, 0xFF, 0xFE, 0x82, 0x5F, 0x25, 0x6A, - 0xFD, 0x77, 0x20, 0x7B, 0x30, 0x5A, 0xAA, 0xA0, 0xDB, 0x1E, 0x92, 0xBF, 0x0D, 0x26, 0x44, 0xD1, - 0xA9, 0x5F, 0x78, 0x0D, 0xC0, 0x8D, 0xF4, 0x10, 0x80, 0x60, 0x01, 0x87, 0xFF, 0xD0, 0x27, 0x18, - 0x69, 0xEE, 0xAA, 0xFA, 0xD5, 0x6F, 0xF1, 0x54, 0xE7, 0x26, 0x61, 0x5F, 0xD2, 0xB9, 0x95, 0x12, - 0xCC, 0x61, 0x95, 0x2A, 0x85, 0x23, 0x87, 0xF3, 0x21, 0x0D, 0x4F, 0x37, 0xFF, 0xFC, 0xD6, 0xF6, - 0x53, 0xDB, 0xA1, 0x5A, 0x82, 0x02, 0x00, 0xF3, 0x06, 0xA1, 0xE3, 0x31, 0x73, 0x0A, 0x43, 0x12, - 0xD4, 0xA6, 0x32, 0x20, 0x02, 0x23, 0x09, 0x60, 0xF1, 0x35, 0x11, 0xF3, 0xBB, 0x5E, 0x01, 0x14, - 0x98, 0x03, 0xE0, 0xEB, 0xC2, 0x1A, 0xC8, 0x91, 0x07, 0x19, 0x0E, 0x25, 0x1C, 0x68, 0x3A, 0x0A, - 0x69, 0x5D, 0x59, 0xD6, 0xCB, 0x9C, 0xD4, 0x65, 0xC1, 0xA7, 0x5A, 0x77, 0xA9, 0x31, 0xA7, 0xAE, - 0x9D, 0xEF, 0x35, 0x01, 0x40, 0x00, 0x70, 0xDC, 0xDA, 0x5C, 0x29, 0xDC, 0x18, 0x76, 0x10, 0xFE, - 0x22, 0xB8, 0xA0, 0xA6, 0xF6, 0x46, 0x20, 0x20, 0xFE, 0x0C, 0x46, 0xC3, 0x00, 0x15, 0x21, 0x52, - 0x85, 0x93, 0x56, 0x90, 0xAE, 0x61, 0xE1, 0xAA, 0xB5, 0x32, 0x56, 0x45, 0xD9, 0x8D, 0x66, 0x71, - 0x02, 0xB9, 0xB5, 0xDC, 0x6E, 0xFF, 0x39, 0xFF, 0xFF, 0xFF, 0xFA, 0xEF, 0x1C, 0x4B, 0xD5, 0xAD, - 0x76, 0xC4, 0x38, 0xDC, 0x1E, 0xFA, 0x19, 0x0D, 0x35, 0xC5, 0xE1, 0xC7, 0xF1, 0xB3, 0x20, 0xDB, - 0x67, 0xB4, 0x01, 0x00, 0x17, 0x2F, 0xFF, 0x73, 0x2C, 0x11, 0xB2, 0x72, 0xA0, 0x5B, 0x15, 0x5A, - 0x5F, 0x42, 0x1F, 0xE8, 0x24, 0x20, 0x83, 0xFA, 0x1D, 0x24, 0x22, 0x81, 0x9F, 0x40, 0x05, 0x3C, - 0x8B, 0x9C, 0xE1, 0xCF, 0x0E, 0x2F, 0xFF, 0xEA, 0x77, 0xE2, 0xFD, 0x5A, 0x10, 0x5B, 0x84, 0x60, - 0xE2, 0xEA, 0x2D, 0xD1, 0x84, 0x00, 0x85, 0x04, 0x1F, 0x39, 0x95, 0x9A, 0x10, 0x99, 0xFB, 0x00, - 0x69, 0x84, 0x10, 0xAF, 0x18, 0xEA, 0xE9, 0xDB, 0xC5, 0x98, 0x28, 0xE9, 0x83, 0x5D, 0x84, 0x3E, - 0x39, 0xAE, 0x0B, 0xA2, 0x35, 0x10, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x0F, 0xB4, 0x8F, 0x34, 0x49, - 0x83, 0xDB, 0xD1, 0x12, 0x31, 0x25, 0xB9, 0x74, 0x1C, 0xC2, 0xC2, 0x51, 0x30, 0xD1, 0x2A, 0x0F, - 0x6F, 0x22, 0x80, 0xAD, 0x19, 0x65, 0x14, 0x04, 0x1D, 0x2B, 0xC0, 0x8B, 0x16, 0x8C, 0x2A, 0x70, - 0x7C, 0x24, 0x4A, 0x07, 0xE5, 0xB4, 0x9D, 0xA6, 0x66, 0x12, 0x07, 0x6A, 0x53, 0x34, 0xFD, 0xB4, - 0xFA, 0x78, 0xB4, 0xAD, 0xE1, 0x5F, 0xCF, 0xB0, 0xA8, 0xA1, 0xB0, 0x52, 0x7B, 0xDC, 0xC3, 0xEB, - 0xAB, 0x7C, 0x78, 0xB4, 0x09, 0xA6, 0x60, 0x34, 0x88, 0x85, 0x9E, 0x53, 0x6A, 0xE0, 0xFA, 0x31, - 0x06, 0x11, 0x34, 0x89, 0x4B, 0xAE, 0x24, 0x44, 0x03, 0x9C, 0xE1, 0x84, 0x50, 0x38, 0x9A, 0x33, - 0x3F, 0x4D, 0xD9, 0x9D, 0x29, 0x7B, 0x6A, 0xC7, 0xE2, 0x6F, 0x67, 0x7B, 0xDF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFD, 0x33, 0xBE, 0x72, 0x1B, 0x89, 0xAF, 0xB6, 0x54, 0xBC, 0xDF, 0xAC, 0xBF, 0xAF, 0x02, - 0xC0, 0x43, 0xBB, 0x56, 0x96, 0xF1, 0xB9, 0x2A, 0x00, 0x60, 0x01, 0x00, 0xFD, 0x7C, 0x32, 0x49, - 0x4E, 0x12, 0x45, 0x26, 0x09, 0x26, 0xE9, 0x6B, 0x3D, 0xD3, 0xEA, 0x2E, 0x1A, 0xBF, 0x8E, 0xD5, - 0x0C, 0x5E, 0x70, 0x9D, 0x60, 0xC1, 0xC0, 0x26, 0x38, 0x11, 0x19, 0x3A, 0xD1, 0xF0, 0xEC, 0x40, - 0x7F, 0xFF, 0xF8, 0x37, 0xAA, 0xFF, 0xC2, 0x43, 0x5A, 0x12, 0x03, 0x43, 0x02, 0x31, 0x78, 0x31, - 0x63, 0x04, 0x13, 0x01, 0x76, 0x2B, 0x35, 0x7A, 0xD3, 0xBD, 0x8E, 0x35, 0x46, 0x70, 0xA3, 0x11, - 0x28, 0xF1, 0x9F, 0xC9, 0x19, 0x84, 0xA1, 0x25, 0x04, 0xD1, 0xD3, 0x05, 0x15, 0x34, 0x2A, 0x18, - 0x1D, 0x8C, 0x18, 0xF9, 0xE3, 0x9B, 0x30, 0x97, 0xC5, 0xE7, 0xE9, 0xF9, 0x16, 0xA7, 0x79, 0x32, - 0x7B, 0x7E, 0x82, 0x55, 0x22, 0x61, 0x02, 0xC1, 0x48, 0xFF, 0x9A, 0xD4, 0x61, 0x4D, 0x94, 0xE8, - 0xB8, 0xA1, 0x52, 0xCF, 0xB9, 0x8C, 0x17, 0x4E, 0xB2, 0x08, 0x86, 0x37, 0x47, 0x11, 0x2A, 0x44, - 0x9A, 0x3D, 0xBC, 0xA0, 0x06, 0x4B, 0xA4, 0x0E, 0xF1, 0x60, 0x42, 0x03, 0x7D, 0xC5, 0x8A, 0xD2, - 0xBF, 0x15, 0x04, 0x30, 0x0A, 0xD6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE3, 0x17, 0xEB, - 0xC1, 0xB0, 0x2B, 0xC8, 0xE3, 0x4C, 0xD3, 0x63, 0xFD, 0x92, 0x3A, 0xED, 0x99, 0x0A, 0x50, 0x10, - 0xD5, 0x9F, 0xF1, 0x40, 0x12, 0x51, 0xA1, 0xE9, 0xAA, 0xC3, 0xBF, 0x68, 0x3C, 0x69, 0xF7, 0xCA, - 0xEE, 0x6D, 0x87, 0x46, 0xA9, 0xFA, 0x9A, 0x45, 0xA0, 0x0C, 0xE8, 0x8A, 0x50, 0x75, 0x46, 0xAD, - 0x6E, 0x50, 0x68, 0xE3, 0xC2, 0xF7, 0xFF, 0xFF, 0x3D, 0xF4, 0xFA, 0x0A, 0x6F, 0x9A, 0x30, 0x08, - 0x28, 0xC5, 0x12, 0x63, 0x46, 0x82, 0x8F, 0x4C, 0x0A, 0x3E, 0xA8, 0x54, 0xCE, 0xCA, 0x53, 0x04, - 0x8A, 0xC8, 0x41, 0xA0, 0xA0, 0xD9, 0x8F, 0x05, 0xA8, 0x28, 0xBB, 0xE0, 0x42, 0x20, 0x7A, 0x87, - 0xA9, 0x04, 0xEC, 0x4B, 0x89, 0x25, 0xAD, 0xE3, 0xFF, 0xFB, 0x92, 0x64, 0x15, 0x0B, 0xB3, 0xBC, - 0x34, 0xCC, 0x83, 0x99, 0x93, 0x70, 0x34, 0x06, 0x58, 0xF4, 0x29, 0x07, 0x5E, 0x0D, 0xD4, 0xD1, - 0x37, 0x0E, 0xE1, 0xAD, 0xC0, 0xE0, 0x96, 0x63, 0x80, 0xD4, 0xAA, 0x48, 0x2E, 0xED, 0x9D, 0xDF, - 0xD7, 0xEB, 0x53, 0x13, 0xD8, 0x6A, 0x62, 0x5C, 0xD6, 0x1F, 0x9B, 0xFF, 0xFA, 0xB7, 0x05, 0x35, - 0x17, 0xF2, 0x07, 0x0B, 0x0A, 0x5E, 0xB3, 0x18, 0x91, 0xA2, 0x91, 0x11, 0x69, 0x18, 0x59, 0x25, - 0x99, 0x40, 0x12, 0x35, 0xDC, 0x22, 0x31, 0x3F, 0x59, 0xFC, 0x3B, 0x8B, 0x7B, 0x00, 0x36, 0xE1, - 0x2B, 0x1C, 0x94, 0x1F, 0xFF, 0xEA, 0x31, 0x99, 0x96, 0x0D, 0xCC, 0xCD, 0xC6, 0xF9, 0xBB, 0x65, - 0x82, 0x90, 0xB1, 0x91, 0x41, 0xB4, 0x32, 0x25, 0xC3, 0x70, 0x00, 0x00, 0x00, 0x28, 0xA8, 0x2C, - 0x37, 0xF8, 0x32, 0x01, 0x8A, 0x0F, 0x12, 0x1A, 0x12, 0x63, 0xF0, 0x74, 0x09, 0x88, 0x01, 0x49, - 0x72, 0x47, 0x0F, 0xD6, 0xBE, 0xBF, 0xF7, 0x7E, 0x90, 0x69, 0x28, 0x43, 0xE7, 0x5B, 0xCF, 0x88, - 0x00, 0x1C, 0x90, 0xF0, 0x8C, 0xFF, 0xFF, 0xD0, 0x01, 0x4B, 0xFF, 0x98, 0x28, 0x70, 0x0C, 0x12, - 0x07, 0x02, 0x0E, 0xC3, 0x18, 0x08, 0x43, 0x04, 0xB1, 0x03, 0x00, 0x05, 0x41, 0x08, 0xD8, 0x81, - 0x03, 0x0C, 0x00, 0x24, 0x91, 0x12, 0x31, 0xD1, 0x59, 0x75, 0xB0, 0x12, 0x60, 0x08, 0x74, 0x01, - 0x55, 0xAB, 0x5D, 0x5A, 0x68, 0x2E, 0x63, 0xF2, 0x0D, 0x63, 0x8E, 0x55, 0x31, 0xB7, 0x6B, 0x0E, - 0x7E, 0x72, 0x38, 0xD4, 0x6F, 0x08, 0x47, 0x33, 0xD6, 0xFA, 0xF2, 0x34, 0x67, 0xC0, 0xBE, 0x8F, - 0xD1, 0x0D, 0x99, 0xB9, 0x74, 0x9C, 0x10, 0xAB, 0x5C, 0x96, 0xDE, 0x10, 0xFE, 0x85, 0x0C, 0xEB, - 0xA6, 0x9C, 0x69, 0x85, 0xC3, 0xAB, 0x05, 0x60, 0x1D, 0x07, 0xFF, 0xFF, 0xD5, 0x5A, 0x27, 0x48, - 0x45, 0x13, 0x27, 0xD4, 0x56, 0x54, 0x5C, 0x12, 0x71, 0x94, 0x27, 0xA8, 0x84, 0x40, 0x22, 0x37, - 0xB6, 0xB0, 0x6F, 0x85, 0xE0, 0x4D, 0x07, 0xD4, 0x39, 0x7C, 0x78, 0x10, 0x7A, 0x57, 0x1D, 0x3C, - 0x8A, 0x08, 0x3D, 0x08, 0x1E, 0xC2, 0xE2, 0x37, 0xF0, 0x46, 0x29, 0xC2, 0x8C, 0x41, 0x8A, 0x43, - 0x01, 0xA8, 0xDB, 0xC4, 0x60, 0x2A, 0x19, 0x17, 0x85, 0xE4, 0x60, 0x5C, 0x20, 0x39, 0xFF, 0xFF, - 0xD0, 0x99, 0xFD, 0x44, 0x6A, 0x00, 0x00, 0x24, 0x00, 0x2F, 0x81, 0x8D, 0x4F, 0x06, 0xC8, 0x0C, - 0x1C, 0xE4, 0xDE, 0x2E, 0x60, 0x32, 0x79, 0x74, 0x48, 0x08, 0x40, 0x07, 0x11, 0x05, 0x8C, 0x34, - 0x20, 0x81, 0x55, 0xAC, 0xBF, 0xAA, 0xD6, 0x48, 0x03, 0x8F, 0x92, 0x96, 0x33, 0x7F, 0xE8, 0xFB, - 0x0F, 0xDF, 0xDF, 0x2F, 0x67, 0x6F, 0x3B, 0x59, 0xE3, 0xFC, 0x96, 0xDB, 0x97, 0x4F, 0xCE, 0xDE, - 0xD7, 0xFC, 0xA2, 0x05, 0x91, 0xCE, 0xA5, 0x9C, 0x00, 0x04, 0x0C, 0x55, 0x86, 0x40, 0x84, 0xFA, - 0x58, 0x42, 0x81, 0xB1, 0x8B, 0x21, 0x5A, 0x2C, 0xC5, 0x49, 0xFF, 0xFB, 0x92, 0x64, 0x2A, 0x8B, - 0x03, 0x5E, 0x33, 0xCE, 0x43, 0x98, 0x6B, 0x72, 0x36, 0x64, 0x49, 0x45, 0x24, 0x4C, 0x76, 0x8D, - 0xD4, 0xD1, 0x3A, 0x8E, 0xE1, 0x4D, 0xC0, 0xCF, 0x17, 0x66, 0xE4, 0x93, 0x09, 0xB8, 0xA9, 0x25, - 0x22, 0xAC, 0x64, 0x01, 0xC1, 0xFF, 0xFF, 0xEA, 0x52, 0x25, 0x23, 0xDD, 0x43, 0xC8, 0x98, 0x4A, - 0x05, 0x19, 0xF1, 0xEA, 0x30, 0x80, 0x00, 0x03, 0x47, 0x77, 0xFB, 0x28, 0xEE, 0x40, 0xE1, 0xC0, - 0xA8, 0xC1, 0xF4, 0x68, 0xF6, 0x55, 0x45, 0xF7, 0x81, 0x8E, 0x71, 0xB1, 0xC5, 0x36, 0xBC, 0xBD, - 0xF3, 0x93, 0x2C, 0x3E, 0xFD, 0xCE, 0x02, 0x7B, 0x46, 0x13, 0xD0, 0x90, 0xB5, 0xFF, 0x02, 0x86, - 0x9D, 0x3A, 0x8A, 0x89, 0x49, 0xFF, 0xFD, 0x67, 0xE4, 0x0B, 0xC9, 0x80, 0x60, 0x43, 0x13, 0x0A, - 0x4A, 0xB3, 0x20, 0x04, 0x73, 0x08, 0x29, 0x73, 0x14, 0xC5, 0x93, 0x14, 0x82, 0xE0, 0x70, 0x24, - 0x60, 0xF0, 0x50, 0xA6, 0xE6, 0x20, 0x00, 0xAB, 0xD5, 0xAD, 0x15, 0x40, 0x18, 0x92, 0x6D, 0xB7, - 0xED, 0x41, 0xB3, 0xE7, 0x76, 0x59, 0x76, 0x02, 0x7D, 0xE8, 0xE1, 0xDD, 0xD7, 0xBF, 0x49, 0x7E, - 0xFC, 0xB2, 0xE7, 0xE5, 0x5E, 0x28, 0xFE, 0x5B, 0x95, 0x5E, 0xDD, 0x47, 0x82, 0x6D, 0xBB, 0xD3, - 0xA7, 0xC3, 0x63, 0x23, 0x74, 0xA9, 0x9A, 0xAF, 0x82, 0x69, 0x15, 0x48, 0x9E, 0x4C, 0x6A, 0x12, - 0x49, 0x36, 0xF1, 0xA4, 0xE9, 0xF9, 0x7D, 0x9F, 0xD6, 0x88, 0x14, 0xB3, 0xFF, 0xFF, 0xF3, 0x18, - 0x8C, 0x9C, 0x93, 0xAC, 0x32, 0x26, 0x0B, 0x83, 0xC8, 0x98, 0x60, 0x00, 0x78, 0x07, 0x00, 0xE7, - 0xF7, 0xFB, 0x90, 0xFE, 0xA5, 0x98, 0x55, 0xC8, 0x56, 0x5C, 0x7C, 0xEF, 0x1E, 0xEF, 0x52, 0xCA, - 0x24, 0x69, 0x8A, 0xF2, 0xD7, 0x96, 0xAD, 0xFD, 0xA9, 0xD5, 0xE9, 0x64, 0xCC, 0x30, 0x31, 0xE4, - 0x4F, 0x10, 0x52, 0xF1, 0xF2, 0xE3, 0x13, 0xFF, 0xFF, 0xF5, 0x41, 0x52, 0xD9, 0x4A, 0x00, 0x80, - 0x03, 0x65, 0x30, 0x23, 0xFC, 0xC2, 0x61, 0x03, 0x81, 0x33, 0x8E, 0x26, 0x0E, 0x31, 0xD9, 0x60, - 0xC0, 0x80, 0xA3, 0x13, 0x92, 0xD1, 0xFC, 0xCB, 0xE2, 0x12, 0x60, 0x12, 0xB0, 0x0A, 0x02, 0xD9, - 0xAB, 0x09, 0x6A, 0x64, 0x24, 0xB7, 0x7B, 0x54, 0xF6, 0xE3, 0x32, 0xFB, 0x58, 0xDF, 0xD5, 0x36, - 0x39, 0x47, 0x32, 0xBB, 0x77, 0x55, 0xE4, 0xF2, 0x77, 0x29, 0xDD, 0x8B, 0xD5, 0x85, 0x4A, 0x3E, - 0x00, 0xC9, 0x0C, 0x98, 0x88, 0x66, 0x5B, 0x72, 0xF9, 0x35, 0x84, 0x8C, 0x58, 0x26, 0xDD, 0x99, - 0x4F, 0x36, 0x35, 0x62, 0x61, 0x8F, 0xFB, 0x5F, 0x87, 0x9A, 0x75, 0xA8, 0x10, 0x7F, 0xFF, 0xFF, - 0x00, 0xD4, 0x0A, 0x3B, 0xD0, 0x48, 0x44, 0x58, 0x18, 0x2D, 0x81, 0x08, 0x6B, 0xA0, 0x00, 0x00, - 0xE0, 0x00, 0x11, 0xB0, 0x41, 0x0F, 0x04, 0x11, 0x08, 0x4E, 0xFB, 0xD2, 0x14, 0x5E, 0xCF, 0x8C, - 0xF6, 0x8B, 0x10, 0xD1, 0x18, 0xAE, 0x42, 0x02, 0x4C, 0x51, 0x85, 0xCF, 0xFF, 0xFB, 0x92, 0x64, - 0x47, 0x0E, 0xE3, 0x62, 0x34, 0x4E, 0xAB, 0x98, 0x2B, 0x70, 0x38, 0x23, 0xF9, 0x71, 0x1C, 0xC9, - 0x4C, 0x0C, 0xFC, 0xCB, 0x42, 0x6E, 0x3D, 0x6F, 0x88, 0xDC, 0x10, 0xE6, 0xC8, 0x90, 0xA6, 0x08, - 0xD1, 0x05, 0x87, 0x82, 0x44, 0xE3, 0x6A, 0xA6, 0x30, 0xA0, 0x88, 0xAF, 0x89, 0xA6, 0x17, 0x68, - 0x39, 0xFD, 0x2D, 0xE8, 0x43, 0x83, 0x51, 0x80, 0x20, 0x93, 0x03, 0x19, 0xCC, 0x8A, 0x06, 0x30, - 0xFD, 0x80, 0xC3, 0x80, 0x60, 0xA9, 0xED, 0x0A, 0x8C, 0x14, 0x1A, 0x2D, 0x21, 0x88, 0x02, 0xCA, - 0xAA, 0xAE, 0xDA, 0x73, 0x1D, 0x70, 0xD4, 0x9C, 0x49, 0xE4, 0x81, 0x11, 0xAD, 0x8D, 0x82, 0xB2, - 0xED, 0x83, 0x78, 0x72, 0xC2, 0xB2, 0x24, 0x18, 0x76, 0x5B, 0x30, 0x1A, 0x91, 0xB9, 0x60, 0x5F, - 0x9A, 0x09, 0xFF, 0x19, 0x8E, 0x38, 0xE8, 0x06, 0x42, 0x9C, 0x7C, 0xB9, 0x86, 0xD9, 0x72, 0x52, - 0x5C, 0xC7, 0x43, 0xC9, 0x23, 0x1B, 0x4E, 0x55, 0xC9, 0x88, 0xAA, 0x43, 0xAA, 0x1F, 0xFF, 0xFF, - 0xFE, 0x6E, 0x7D, 0xE7, 0xC3, 0x84, 0xD2, 0xD3, 0x97, 0x0F, 0xB6, 0xB8, 0xE1, 0xD5, 0x4C, 0x06, - 0xB7, 0x17, 0x47, 0x44, 0xF0, 0x11, 0x9C, 0x20, 0x49, 0x29, 0x87, 0x87, 0x48, 0x1E, 0x92, 0x39, - 0xF4, 0x7D, 0x43, 0xB4, 0x77, 0x04, 0xD9, 0x92, 0x72, 0x51, 0x01, 0x79, 0x1A, 0xB0, 0xF1, 0xCA, - 0x33, 0xAB, 0x0E, 0x2C, 0xB0, 0x91, 0x19, 0xC4, 0x89, 0xC9, 0x4A, 0xB4, 0x93, 0x64, 0x32, 0x58, - 0xAF, 0xF2, 0x12, 0xFB, 0x24, 0x6A, 0x00, 0x34, 0x0A, 0x71, 0xA4, 0x12, 0x90, 0x30, 0x35, 0xB8, - 0x3E, 0x14, 0x2E, 0xA6, 0x7D, 0xAF, 0x26, 0xF6, 0xC6, 0x66, 0x23, 0x66, 0xAE, 0xF6, 0x12, 0x63, - 0x63, 0x94, 0x54, 0x2A, 0x76, 0xEC, 0x68, 0x0E, 0xD2, 0xE2, 0xC1, 0x16, 0x09, 0x2A, 0x64, 0x18, - 0xA9, 0xCA, 0x24, 0xDF, 0x9D, 0xEF, 0x19, 0x0F, 0xE4, 0x62, 0x85, 0x36, 0x50, 0x27, 0x81, 0xF0, - 0xA1, 0x00, 0xF0, 0x7B, 0x0E, 0x71, 0x8A, 0x48, 0x2C, 0x84, 0x23, 0xC6, 0x19, 0xC8, 0x01, 0x80, - 0x0C, 0x90, 0x98, 0x0B, 0x81, 0xE2, 0x0D, 0x71, 0xCC, 0x2F, 0x43, 0xFC, 0xCB, 0x16, 0x55, 0xD8, - 0x9C, 0x21, 0x48, 0x8A, 0x45, 0xE4, 0xAA, 0x8D, 0x78, 0x60, 0xD7, 0xFF, 0xFF, 0xFF, 0xFB, 0x2E, - 0x09, 0x63, 0x3C, 0xA6, 0x12, 0x44, 0xC5, 0x90, 0xF2, 0x40, 0x7E, 0xA3, 0x2D, 0x7F, 0x1C, 0xE7, - 0xD9, 0x61, 0xFC, 0xFD, 0x12, 0x18, 0x97, 0x1F, 0x15, 0xB4, 0x95, 0xBC, 0xBB, 0x79, 0xF5, 0xA4, - 0xD8, 0x9F, 0xAC, 0xAF, 0xFA, 0x2C, 0xDB, 0x3E, 0x37, 0xAA, 0x4A, 0x24, 0xCC, 0x18, 0xC9, 0x74, - 0x27, 0xCA, 0x90, 0x09, 0x12, 0x64, 0xD1, 0x0A, 0x39, 0xE9, 0xCD, 0x4A, 0x92, 0xC9, 0x85, 0x7F, - 0x78, 0xA9, 0x72, 0xE4, 0x2A, 0x20, 0x1F, 0x61, 0x47, 0x81, 0x17, 0x81, 0x99, 0xCD, 0xF0, 0x33, - 0x39, 0x38, 0xF9, 0x82, 0x38, 0x97, 0x48, 0xF3, 0x19, 0xA5, 0xC2, 0xC4, 0xC4, 0x10, 0xFF, 0xFB, - 0x92, 0x64, 0x64, 0x0A, 0x73, 0xD5, 0x33, 0x4F, 0x93, 0x78, 0x7A, 0x10, 0x34, 0x64, 0x29, 0xF0, - 0x05, 0xA9, 0x00, 0x0D, 0x80, 0xCD, 0x46, 0xAD, 0x3C, 0xED, 0xD0, 0xD0, 0x12, 0x27, 0xD4, 0x90, - 0x99, 0xC2, 0xC6, 0x87, 0x8A, 0x80, 0x5E, 0x6C, 0x27, 0x33, 0x7D, 0x5D, 0x59, 0x57, 0x48, 0x0C, - 0x7A, 0xB3, 0x5B, 0x15, 0xA6, 0x76, 0xCC, 0xDA, 0xB2, 0xC0, 0x84, 0x03, 0x21, 0x2A, 0x22, 0xC2, - 0xE6, 0x34, 0xDB, 0x11, 0x59, 0x6A, 0xB1, 0xFA, 0x5B, 0xC1, 0xB6, 0x76, 0x04, 0x18, 0xBA, 0x08, - 0xC2, 0xE0, 0xD2, 0x74, 0xBB, 0x19, 0x63, 0x58, 0xFA, 0x6A, 0x3B, 0x0D, 0x75, 0x72, 0xB2, 0xD0, - 0x86, 0x23, 0x16, 0x24, 0xDF, 0xFA, 0x05, 0x99, 0x94, 0x17, 0x8D, 0x02, 0xA3, 0x72, 0x63, 0xC2, - 0xA6, 0x53, 0xC6, 0x83, 0x44, 0x83, 0x36, 0x84, 0xA2, 0xF0, 0x36, 0xCF, 0x4C, 0xC1, 0x34, 0x42, - 0xC7, 0xD5, 0x6B, 0xAD, 0x51, 0x2D, 0xDD, 0x83, 0xFF, 0xDF, 0x83, 0xB3, 0x0D, 0x40, 0x95, 0x89, - 0x67, 0xCE, 0xFC, 0x42, 0xFE, 0xC2, 0x88, 0x12, 0xB1, 0x93, 0xA0, 0xAC, 0xD4, 0x52, 0x5F, 0x8B, - 0x53, 0xA3, 0xF9, 0x54, 0x80, 0x83, 0x48, 0x0E, 0x6C, 0x01, 0x80, 0x06, 0x60, 0xD3, 0xE1, 0x62, - 0x61, 0x13, 0x28, 0x40, 0xA0, 0x16, 0xC0, 0x3A, 0x38, 0xC2, 0x76, 0x8E, 0xD4, 0x74, 0x28, 0x6C, - 0xC1, 0x0C, 0x08, 0xF0, 0x89, 0x18, 0x40, 0x17, 0x1E, 0x9F, 0xBC, 0xD8, 0x22, 0x78, 0x72, 0x23, - 0x56, 0x83, 0xB5, 0xED, 0x50, 0xFD, 0xCE, 0xEE, 0x6A, 0x5C, 0xF0, 0x34, 0xFA, 0x80, 0x60, 0x70, - 0x10, 0x32, 0x25, 0xC4, 0x58, 0x53, 0xBA, 0xDC, 0x61, 0x59, 0xE0, 0xF4, 0xB5, 0x95, 0xA8, 0x5F, - 0x55, 0x04, 0x5C, 0x10, 0xF3, 0x29, 0x65, 0xB7, 0x20, 0xB5, 0xF6, 0xB0, 0xED, 0xEB, 0x38, 0x9E, - 0x93, 0xAE, 0xD7, 0xD2, 0xF4, 0x1B, 0x85, 0x18, 0x4F, 0xFF, 0xFD, 0x9C, 0x0C, 0xC0, 0xA2, 0x20, - 0x34, 0x00, 0x91, 0x22, 0x07, 0x6D, 0xC1, 0x93, 0x6D, 0xD4, 0x80, 0x31, 0x34, 0xA5, 0x2D, 0x8A, - 0x14, 0x28, 0x59, 0x84, 0x9A, 0x9F, 0x4C, 0xD6, 0x34, 0x51, 0xC8, 0x2B, 0x8B, 0x68, 0x71, 0x41, - 0xFA, 0xA9, 0x61, 0x19, 0x1F, 0xF0, 0x03, 0x8E, 0xA3, 0x50, 0x1B, 0x1A, 0xC3, 0x01, 0xD3, 0x56, - 0xA9, 0x06, 0xAA, 0xD2, 0xA8, 0x9C, 0x9F, 0xFD, 0x0C, 0x72, 0x83, 0x3A, 0x8A, 0x2D, 0xED, 0x3B, - 0x24, 0x01, 0x01, 0xE0, 0x11, 0x09, 0xB4, 0x30, 0x6A, 0x60, 0x94, 0x70, 0xD2, 0x4C, 0x1A, 0xD2, - 0x39, 0x48, 0xC5, 0x23, 0x94, 0x80, 0x14, 0x94, 0x02, 0x3B, 0xA6, 0x5C, 0x2F, 0x9B, 0x86, 0xA1, - 0xCE, 0x6E, 0xFD, 0x4E, 0x51, 0x57, 0xA7, 0xE4, 0xDF, 0x72, 0xCB, 0x2C, 0xA1, 0xB8, 0xCA, 0x61, - 0x83, 0x0E, 0x2D, 0x78, 0x2D, 0x5C, 0x30, 0x58, 0xAC, 0x45, 0xCE, 0xBB, 0x66, 0xB2, 0x0E, 0x31, - 0x50, 0x5A, 0x1B, 0xC5, 0x61, 0x42, 0x73, 0x14, 0x87, 0xAD, 0x3E, 0x10, 0xB4, 0xA9, 0x61, 0x8C, - 0xFF, 0xFB, 0x92, 0x64, 0x7B, 0x8B, 0xF3, 0x7C, 0x33, 0x51, 0x2B, 0x62, 0x37, 0x00, 0x36, 0xA5, - 0x99, 0x80, 0x25, 0x02, 0x6E, 0x4D, 0x48, 0xCB, 0x44, 0x0E, 0x60, 0xED, 0xC8, 0xD8, 0x96, 0xA5, - 0xC0, 0x90, 0x2C, 0x28, 0xF1, 0xB3, 0x45, 0x21, 0x70, 0x1F, 0x37, 0x34, 0xD4, 0x7F, 0xFF, 0x1C, - 0x38, 0x6A, 0x60, 0xD0, 0x74, 0x1C, 0xB0, 0xBC, 0x74, 0x95, 0xC4, 0x51, 0x88, 0xA2, 0x6D, 0x94, - 0x0E, 0x5B, 0x8D, 0x2B, 0xB6, 0xB4, 0x80, 0x59, 0xDD, 0x71, 0xA0, 0x50, 0x43, 0xAD, 0xC8, 0x7F, - 0x13, 0x8D, 0x20, 0x96, 0x4F, 0xF4, 0xC7, 0x72, 0xE1, 0x40, 0x73, 0xA2, 0xCE, 0xCA, 0x72, 0x82, - 0xC2, 0x59, 0x0E, 0x3D, 0x97, 0x9B, 0xF1, 0xDC, 0xC4, 0x19, 0xFF, 0xFF, 0xFF, 0x11, 0xA6, 0x42, - 0x3C, 0xA0, 0x0E, 0xBA, 0x00, 0x02, 0x00, 0x03, 0x00, 0x25, 0x21, 0x50, 0x18, 0xF1, 0x5C, 0x44, - 0x43, 0x33, 0x30, 0x00, 0x02, 0x14, 0x35, 0x18, 0x4C, 0xC6, 0x22, 0x13, 0xA9, 0x8D, 0x0C, 0x1C, - 0x05, 0x6F, 0x47, 0x80, 0xC1, 0x10, 0xA4, 0x29, 0x04, 0x02, 0x11, 0x15, 0xEF, 0x8B, 0x43, 0x36, - 0x25, 0x56, 0xE6, 0x6F, 0x4F, 0x63, 0x9E, 0x56, 0x2F, 0xFF, 0xFD, 0x57, 0x66, 0x85, 0x1E, 0x43, - 0x8E, 0x5A, 0x96, 0xFD, 0x9E, 0xB1, 0x1E, 0xC7, 0x75, 0xBC, 0x63, 0x8E, 0xD2, 0x72, 0x85, 0x48, - 0x9D, 0xED, 0x39, 0x33, 0xA0, 0x9E, 0x69, 0xEA, 0x85, 0xAB, 0x96, 0xDE, 0x3E, 0xCF, 0xA1, 0xC9, - 0x43, 0xFD, 0xF9, 0x69, 0xFF, 0xF8, 0x75, 0x16, 0xA0, 0x2A, 0x29, 0x06, 0x45, 0x75, 0x3A, 0x81, - 0x09, 0xA0, 0x00, 0x00, 0xC0, 0xA0, 0x26, 0x40, 0x5A, 0x8F, 0x9C, 0x5C, 0x54, 0xD4, 0x7D, 0x5D, - 0xBC, 0x60, 0x70, 0x49, 0x7C, 0x80, 0xFA, 0x9A, 0x43, 0x2A, 0x36, 0x8A, 0x86, 0x28, 0xD8, 0xA8, - 0xC1, 0xB0, 0x3D, 0x34, 0x23, 0x38, 0xFF, 0xF3, 0x3F, 0xFA, 0x1F, 0x34, 0x9B, 0xA1, 0xAE, 0xE5, - 0x16, 0xA7, 0x13, 0xFE, 0xBB, 0x31, 0x60, 0x62, 0x52, 0x42, 0x2D, 0x12, 0x49, 0x95, 0x00, 0xA6, - 0x88, 0x02, 0x0A, 0x88, 0xCC, 0x92, 0x7A, 0x30, 0x40, 0xF4, 0xE7, 0x0A, 0x43, 0x0F, 0x83, 0xC1, - 0x80, 0xC0, 0x50, 0xCC, 0xC9, 0x02, 0xB0, 0xC1, 0x5A, 0xBF, 0x08, 0x05, 0x2B, 0x6F, 0x2C, 0x9F, - 0xBD, 0x6F, 0x3A, 0xD4, 0x94, 0xB4, 0x73, 0x7F, 0xDC, 0x3F, 0x9A, 0xCA, 0x19, 0x76, 0x40, 0x82, - 0x08, 0x3A, 0xE5, 0x7D, 0x1F, 0xAC, 0xA8, 0x69, 0x79, 0xBC, 0xA2, 0x25, 0xFE, 0x05, 0x28, 0x58, - 0x0C, 0x81, 0xA3, 0xD2, 0x72, 0xC3, 0x60, 0x91, 0x41, 0x6E, 0x7B, 0x5F, 0x65, 0x2D, 0x2E, 0x66, - 0x97, 0x8F, 0xFF, 0xFF, 0x51, 0xE2, 0xB1, 0x50, 0xFC, 0x83, 0x13, 0xCA, 0xE3, 0xC0, 0x80, 0x23, - 0x06, 0x01, 0xDC, 0x28, 0x3E, 0xDF, 0xFE, 0x2A, 0x14, 0xAE, 0x8D, 0x42, 0xB9, 0x47, 0xCF, 0x9D, - 0x88, 0x06, 0x77, 0x07, 0xD3, 0x27, 0x59, 0xCE, 0x8F, 0xE2, 0xF7, 0xD6, 0xA5, 0x49, 0x85, 0x43, - 0x60, 0xA1, 0xFF, 0xFB, 0x92, 0x64, 0x97, 0x0B, 0x73, 0x68, 0x33, 0x51, 0x4B, 0x98, 0x13, 0x72, - 0x35, 0x86, 0x19, 0xC7, 0x04, 0x07, 0x26, 0x0D, 0x34, 0xD3, 0x45, 0x0E, 0x60, 0xAD, 0xC0, 0xCA, - 0x16, 0xE6, 0xA0, 0x55, 0x9E, 0xC9, 0x32, 0xA8, 0x23, 0x06, 0x8E, 0xFE, 0x9F, 0xFD, 0x18, 0xE7, - 0x22, 0x63, 0x4F, 0x6B, 0xEA, 0xC5, 0x05, 0x95, 0x08, 0x95, 0x40, 0x4B, 0xC9, 0x3E, 0x67, 0xEC, - 0x64, 0x01, 0x67, 0x2D, 0xC2, 0x61, 0x64, 0xA7, 0xDB, 0x78, 0x7C, 0xA0, 0x06, 0x06, 0x88, 0x00, - 0x16, 0x57, 0x47, 0x3E, 0x2A, 0xD3, 0x41, 0xE5, 0x59, 0x8B, 0x62, 0x5F, 0x02, 0x64, 0xD8, 0xBB, - 0x11, 0x96, 0xD7, 0xB9, 0x29, 0x87, 0x2D, 0x4F, 0xDB, 0xBB, 0xC6, 0x78, 0xB2, 0xD2, 0x19, 0x65, - 0x3E, 0x88, 0x0B, 0x62, 0x8C, 0xBE, 0x57, 0x8D, 0x05, 0x79, 0x99, 0x52, 0x81, 0x80, 0x1A, 0xCF, - 0x5B, 0x88, 0x90, 0x57, 0x63, 0xDB, 0x6B, 0x25, 0x95, 0x1B, 0x69, 0x0A, 0xA8, 0xC4, 0xD6, 0x8D, - 0x34, 0x8F, 0x9F, 0xE6, 0x27, 0xFF, 0xA9, 0xA8, 0x3E, 0x2A, 0x55, 0x1D, 0xB6, 0xAA, 0x50, 0x52, - 0x18, 0x1B, 0x0C, 0x30, 0x04, 0x00, 0x18, 0x5D, 0x02, 0x6F, 0xFF, 0xE9, 0xF3, 0xCD, 0x6D, 0x98, - 0x23, 0x5F, 0xC1, 0x02, 0x15, 0x3D, 0xC1, 0x1A, 0x06, 0xBF, 0xE1, 0xFB, 0x62, 0x24, 0xB6, 0x59, - 0x4B, 0x3C, 0x7E, 0xD1, 0x9C, 0x6E, 0xD9, 0x1A, 0x84, 0x48, 0x9A, 0xA5, 0xAB, 0xFF, 0xFA, 0xB9, - 0x3F, 0xEC, 0x10, 0x2B, 0x23, 0xFD, 0x46, 0x5D, 0x1C, 0x88, 0x10, 0x0F, 0x32, 0xE0, 0x50, 0x00, - 0x0D, 0x00, 0x9B, 0x94, 0xD8, 0xC5, 0x51, 0xC2, 0x00, 0x89, 0x85, 0x30, 0xA7, 0x5B, 0x1C, 0xAB, - 0x30, 0x84, 0x32, 0x5B, 0x31, 0x44, 0x70, 0x90, 0xC0, 0x2E, 0xC4, 0xE1, 0x7A, 0xD7, 0xBC, 0x92, - 0x37, 0x75, 0xAF, 0xD7, 0x8C, 0xC5, 0xAA, 0xC3, 0x92, 0x88, 0x4B, 0xF0, 0xE0, 0x45, 0xEB, 0x35, - 0x44, 0xAA, 0x12, 0x10, 0x26, 0x48, 0x4B, 0x66, 0x29, 0x21, 0x2D, 0x8D, 0x47, 0x1F, 0x3C, 0xA5, - 0x0F, 0x72, 0xF2, 0x04, 0x8D, 0x1D, 0x52, 0x11, 0x81, 0x2C, 0x66, 0xDF, 0x3F, 0x95, 0x3D, 0x2F, - 0x1A, 0xD5, 0x64, 0xF0, 0x63, 0x62, 0xEF, 0x7F, 0xC7, 0x4F, 0xFF, 0xFE, 0xAC, 0x10, 0xF6, 0xD5, - 0xCA, 0x0E, 0x20, 0xE0, 0xD1, 0x8A, 0x67, 0xB7, 0xFF, 0x80, 0x09, 0xCF, 0x1B, 0x1E, 0x54, 0xA0, - 0xA8, 0xAC, 0xE6, 0xA1, 0x94, 0x42, 0x8D, 0x90, 0x90, 0xB8, 0xEE, 0x7F, 0x01, 0x1B, 0xE0, 0xF4, - 0x31, 0x1E, 0x7C, 0xA5, 0x61, 0x41, 0x19, 0xAC, 0xF4, 0x95, 0x89, 0xA5, 0x42, 0x97, 0x7F, 0xFF, - 0x91, 0xBF, 0xF1, 0x94, 0x6A, 0xB7, 0x95, 0xEE, 0x61, 0xD5, 0x02, 0x23, 0xA2, 0x81, 0xC1, 0x41, - 0xC9, 0x83, 0x01, 0x06, 0x2B, 0x37, 0xCA, 0x4C, 0x0A, 0xBE, 0x01, 0x50, 0x4C, 0xF4, 0x8D, 0x3E, - 0x68, 0x00, 0x1C, 0x2A, 0x02, 0x16, 0x07, 0x82, 0xA6, 0x00, 0x0A, 0x99, 0xB8, 0x00, 0x90, 0x65, - 0x01, 0x06, 0xA6, 0xF5, 0xFF, 0xFB, 0x92, 0x64, 0xB6, 0x8F, 0xD3, 0x65, 0x34, 0xD0, 0x03, 0x78, - 0x3B, 0x70, 0x35, 0x06, 0x59, 0xA2, 0x1D, 0x22, 0x6E, 0xCD, 0x94, 0xD3, 0x40, 0x0E, 0x60, 0xED, - 0xC0, 0xD0, 0x1A, 0x65, 0xC0, 0x24, 0x89, 0xF0, 0x51, 0x44, 0xE9, 0xE5, 0xF1, 0x2C, 0x65, 0x17, - 0x66, 0xA4, 0x2C, 0x22, 0x3E, 0xFD, 0x43, 0xF2, 0x35, 0x32, 0x4F, 0x04, 0x19, 0x2B, 0x05, 0xAB, - 0xA6, 0x9E, 0xFD, 0x51, 0xB4, 0x08, 0x32, 0x2A, 0xFC, 0xD8, 0x3F, 0x4C, 0x94, 0x79, 0x04, 0x16, - 0x32, 0xDC, 0x1F, 0xE9, 0xC5, 0x8B, 0xCA, 0x8F, 0x39, 0x98, 0x89, 0x12, 0x1C, 0x87, 0xB8, 0xCF, - 0xD1, 0x85, 0x04, 0x0C, 0x2E, 0xF5, 0xFF, 0xFC, 0x49, 0x39, 0x8F, 0x46, 0xA3, 0x14, 0x38, 0x42, - 0x0F, 0x07, 0xD8, 0x2B, 0xFF, 0xF3, 0x84, 0x95, 0xA9, 0x97, 0x36, 0xEF, 0x63, 0xD6, 0x5A, 0x8A, - 0x5D, 0x66, 0xC8, 0x44, 0xE1, 0xDA, 0xF9, 0x32, 0x39, 0x23, 0x1E, 0x51, 0x43, 0xFB, 0x67, 0x66, - 0x60, 0x13, 0xC0, 0xCE, 0x1A, 0xA4, 0x30, 0x75, 0x90, 0x05, 0x1D, 0xFF, 0xE0, 0xC1, 0x9F, 0xF6, - 0x94, 0xB2, 0xFD, 0x03, 0xCE, 0xA2, 0x20, 0x46, 0x80, 0x0A, 0x28, 0xAF, 0xCD, 0x3E, 0x06, 0x30, - 0x18, 0x10, 0x59, 0x22, 0x24, 0x5F, 0x25, 0x58, 0x0B, 0x5F, 0x4C, 0x40, 0x66, 0x38, 0x03, 0xF0, - 0x58, 0x02, 0x0A, 0x43, 0x8B, 0x14, 0x06, 0x45, 0xC6, 0xFC, 0x1B, 0x3F, 0xE2, 0xFA, 0xBF, 0x1A, - 0x81, 0x23, 0xF4, 0x79, 0xBF, 0x39, 0x65, 0x08, 0xC2, 0x2B, 0x1E, 0x76, 0x9F, 0x89, 0x2C, 0xFD, - 0xE5, 0x9B, 0x03, 0x80, 0xD0, 0xC9, 0x23, 0x32, 0x3A, 0xED, 0x37, 0x4F, 0x9B, 0x57, 0x82, 0x99, - 0x63, 0x38, 0x33, 0x8D, 0x8B, 0x08, 0xC4, 0xC9, 0x18, 0x28, 0xF1, 0x20, 0x5C, 0xE3, 0xEA, 0x24, - 0xEA, 0xCA, 0x63, 0xB3, 0x99, 0x5C, 0xA3, 0xF2, 0xB7, 0x26, 0x4C, 0xD7, 0xFF, 0xFC, 0xC3, 0x4F, - 0x26, 0x12, 0x12, 0x26, 0x5A, 0x59, 0xD5, 0x42, 0x82, 0x28, 0xD1, 0xBE, 0x2D, 0x8D, 0xE1, 0x8E, - 0x75, 0x66, 0xA4, 0x7A, 0x21, 0x60, 0x9F, 0x7F, 0x8D, 0xE7, 0x1B, 0x7B, 0x74, 0x6B, 0x63, 0x27, - 0x6A, 0x9D, 0x14, 0x89, 0x42, 0x40, 0xA0, 0xEA, 0x56, 0xB1, 0x37, 0x04, 0x2C, 0x4A, 0xDF, 0xFE, - 0x82, 0x9B, 0x3A, 0x3D, 0x4B, 0xBF, 0xFF, 0xFA, 0x6E, 0xA5, 0x9B, 0x92, 0x66, 0x62, 0x32, 0x79, - 0x0B, 0x80, 0xC6, 0x06, 0x09, 0x86, 0xD0, 0x1B, 0x04, 0x06, 0x19, 0x82, 0x6D, 0x80, 0x90, 0x50, - 0x62, 0x6B, 0x68, 0x62, 0xA9, 0x46, 0x63, 0x59, 0x30, 0x6B, 0x8D, 0x2E, 0x61, 0x40, 0x0A, 0x62, - 0x62, 0x6A, 0x66, 0x30, 0x1E, 0x60, 0x30, 0xF8, 0x6B, 0xAD, 0x1A, 0x1C, 0xBF, 0x98, 0x9C, 0x18, - 0x81, 0x80, 0xB1, 0x90, 0x63, 0xC1, 0x11, 0xB4, 0x50, 0x23, 0x35, 0x50, 0xC6, 0x2E, 0xFB, 0xC0, - 0x32, 0xB5, 0x02, 0x84, 0xA1, 0xD0, 0x14, 0xB1, 0x7C, 0xB2, 0x42, 0xF7, 0x01, 0x56, 0x00, 0xA5, - 0x9B, 0x79, 0x00, 0x13, 0x69, 0xDA, 0xFF, 0xFB, 0x92, 0x64, 0xD4, 0x06, 0xF3, 0xA6, 0x34, 0xD0, - 0x8B, 0x8F, 0x3E, 0x10, 0x35, 0x46, 0xA9, 0x10, 0x05, 0x85, 0x6C, 0x0E, 0x68, 0xD3, 0x42, 0xAE, - 0x60, 0xED, 0xD0, 0xD2, 0x1A, 0xA2, 0x80, 0x07, 0xB5, 0xA0, 0x24, 0x11, 0x29, 0x84, 0x83, 0x47, - 0x50, 0xC5, 0x12, 0x93, 0xD8, 0x1A, 0x90, 0xC8, 0x0E, 0x22, 0x4A, 0x68, 0x42, 0x45, 0x8C, 0xD9, - 0xB0, 0xE5, 0xE5, 0x44, 0x06, 0x60, 0xE2, 0x4A, 0x22, 0x43, 0x04, 0x4C, 0x68, 0x71, 0xEE, 0x89, - 0x3C, 0xED, 0xC5, 0xEC, 0x8E, 0x16, 0xC8, 0xC7, 0xE1, 0x8C, 0xA0, 0x85, 0x5F, 0xFF, 0xFF, 0xFF, - 0xFF, 0xF9, 0x3F, 0x98, 0x99, 0x5F, 0x97, 0xB6, 0x91, 0xEF, 0x5B, 0x2D, 0x2C, 0x1D, 0x11, 0x4D, - 0xE2, 0xDA, 0x5E, 0x75, 0x1F, 0xFF, 0xCC, 0x95, 0x35, 0x76, 0xB5, 0xA5, 0x7B, 0x3C, 0xD4, 0x3E, - 0x42, 0x51, 0x3D, 0xEF, 0x7D, 0xD2, 0x9B, 0xFB, 0x81, 0x34, 0x7C, 0x67, 0x79, 0xDD, 0x2E, 0x20, - 0x84, 0xA6, 0x8C, 0x71, 0xD8, 0xE7, 0xA6, 0x4C, 0xF1, 0x27, 0x31, 0xF1, 0x9A, 0x56, 0xF8, 0x6C, - 0x80, 0x2E, 0x01, 0x5F, 0xFF, 0xFD, 0x5F, 0x33, 0x2A, 0x49, 0x63, 0x05, 0xE8, 0x5E, 0x1D, 0x02, - 0x80, 0x8C, 0x4E, 0x9B, 0x06, 0x06, 0xCC, 0x46, 0x64, 0x33, 0x00, 0x51, 0x7C, 0x94, 0xA7, 0xCC, - 0x1A, 0x0C, 0x34, 0x71, 0x2C, 0xCC, 0x60, 0x31, 0xC1, 0xC9, 0xAE, 0x06, 0x44, 0x81, 0x43, 0x5F, - 0x5E, 0x0E, 0x60, 0x11, 0x95, 0x85, 0x4B, 0x6F, 0x3E, 0xE4, 0x20, 0x59, 0x96, 0x1E, 0x6B, 0x10, - 0x44, 0x92, 0x5D, 0x39, 0x59, 0x4B, 0xE9, 0x68, 0x65, 0x70, 0xF9, 0x76, 0x16, 0xF8, 0xEC, 0x27, - 0x5D, 0xF2, 0x21, 0xC6, 0x69, 0xE3, 0xDB, 0xEC, 0x9C, 0x42, 0xF4, 0xCF, 0x43, 0x8A, 0xC2, 0x4B, - 0x8F, 0x02, 0x40, 0x2A, 0xB1, 0xA7, 0xCA, 0xB7, 0x23, 0xDB, 0xFE, 0x9E, 0xB3, 0xD5, 0xA7, 0xE5, - 0x71, 0x98, 0x81, 0x63, 0x44, 0x34, 0xB9, 0x2B, 0xFF, 0xF4, 0xCD, 0x0B, 0xA0, 0xA3, 0x0C, 0xC5, - 0xCE, 0x4A, 0x4F, 0x12, 0x07, 0x04, 0x30, 0x96, 0x30, 0x13, 0x01, 0x61, 0x8D, 0xFF, 0xFF, 0xDA, - 0x35, 0xD1, 0xD2, 0x81, 0x88, 0xA3, 0xDE, 0x81, 0xD3, 0xD9, 0xAE, 0xDE, 0xDC, 0x3F, 0x28, 0x42, - 0x6A, 0x2D, 0xCC, 0xC4, 0xE7, 0x03, 0x81, 0x2E, 0x74, 0x36, 0x04, 0x74, 0x7D, 0x00, 0x95, 0xFF, - 0x3F, 0x84, 0xF4, 0x22, 0xBF, 0xFF, 0xFD, 0x5F, 0x3E, 0x42, 0x21, 0x01, 0xB8, 0x71, 0x6A, 0xA3, - 0x11, 0x0C, 0xCC, 0x33, 0x10, 0x30, 0x20, 0xA8, 0x28, 0x11, 0x36, 0x50, 0xF0, 0x42, 0x1F, 0x39, - 0x03, 0xE8, 0x10, 0x10, 0x1D, 0xB5, 0x09, 0x01, 0x44, 0x8B, 0x26, 0x70, 0x66, 0x99, 0x1C, 0x10, - 0x6F, 0x3A, 0x41, 0x44, 0x84, 0x46, 0x0F, 0x30, 0x20, 0x3D, 0x6A, 0x36, 0x14, 0x47, 0x49, 0x66, - 0x8F, 0x6A, 0x1D, 0x99, 0x6C, 0x0D, 0xD2, 0x43, 0x2C, 0xA5, 0x40, 0x0B, 0xBF, 0x2E, 0xF5, 0xF2, - 0x38, 0x22, 0x04, 0x40, 0xAA, 0xE0, 0xAC, 0x54, 0xFF, 0xFB, 0x92, 0x64, 0xEA, 0x0F, 0xF4, 0xFF, - 0x34, 0xCD, 0x03, 0xBA, 0x7B, 0xE0, 0x39, 0xE6, 0x98, 0xF0, 0x05, 0xEA, 0x7C, 0x0F, 0xD0, 0xD3, - 0x40, 0x0E, 0x61, 0x4D, 0xC0, 0xC8, 0x9A, 0x66, 0x80, 0x14, 0x89, 0xB8, 0xF2, 0xF1, 0x69, 0x6D, - 0x09, 0xB9, 0xB5, 0x48, 0x61, 0x11, 0x12, 0xE5, 0x46, 0x58, 0x60, 0x92, 0x41, 0xA8, 0x02, 0xC0, - 0xD9, 0x20, 0xFA, 0x19, 0xAA, 0x80, 0xA6, 0xE4, 0x36, 0xA7, 0xDE, 0x47, 0xF2, 0xF8, 0x8A, 0xDF, - 0x76, 0x8D, 0xA6, 0x02, 0x52, 0x87, 0x0F, 0x84, 0x65, 0x3F, 0xFF, 0xFF, 0xFF, 0xC5, 0x18, 0xE5, - 0x57, 0xAE, 0x97, 0xD1, 0xCF, 0xE8, 0xD4, 0xE5, 0xA5, 0x7B, 0xA6, 0x58, 0xA2, 0x9C, 0x63, 0xAA, - 0x66, 0xD8, 0x00, 0x03, 0x2C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x53, 0xBB, 0x57, 0xAF, 0x43, - 0x30, 0x40, 0xE5, 0x9C, 0x95, 0xFE, 0x94, 0xA6, 0x24, 0xBC, 0x30, 0xF9, 0xF2, 0x54, 0xC1, 0xCA, - 0xFF, 0xBE, 0xCB, 0xA5, 0x16, 0x53, 0xC8, 0x24, 0x28, 0xE0, 0x3B, 0xFF, 0xCC, 0xDB, 0x32, 0x17, - 0x13, 0xBE, 0x02, 0x0B, 0x0E, 0xC2, 0xFE, 0x30, 0xC2, 0x79, 0x94, 0x05, 0x46, 0xF8, 0x11, 0x98, - 0x90, 0x12, 0x70, 0x5A, 0xB9, 0x30, 0x8C, 0xAA, 0xD0, 0x05, 0x31, 0xCC, 0x36, 0x2C, 0x32, 0xED, - 0x98, 0x0C, 0xFF, 0x30, 0x71, 0x1C, 0x04, 0xDD, 0x42, 0x20, 0x20, 0x35, 0x08, 0x20, 0x40, 0x72, - 0x4D, 0xF3, 0x85, 0x52, 0x2E, 0xB7, 0xAD, 0x25, 0x4A, 0xF5, 0x8C, 0x2C, 0xD6, 0x75, 0x11, 0x49, - 0xB8, 0x0A, 0x16, 0xF8, 0x0E, 0x20, 0x7B, 0x1E, 0x5D, 0x92, 0xCE, 0xC5, 0xD5, 0x2C, 0x34, 0x81, - 0x14, 0xD3, 0xA8, 0x60, 0x88, 0x6D, 0x06, 0x8E, 0x21, 0x41, 0x50, 0x81, 0x60, 0x42, 0x01, 0x46, - 0xC3, 0x94, 0x03, 0x58, 0x14, 0x06, 0xA8, 0xB2, 0xD4, 0x68, 0xEF, 0x27, 0x77, 0x28, 0x8D, 0xB3, - 0x96, 0x15, 0x52, 0xA8, 0xC1, 0x57, 0x23, 0x69, 0xFF, 0xFF, 0xDF, 0x5F, 0xE1, 0x16, 0xAF, 0x80, - 0xAD, 0x52, 0x27, 0x8B, 0x7B, 0x4F, 0x7D, 0x69, 0x10, 0x19, 0x27, 0xC2, 0xE8, 0x37, 0x8B, 0x64, - 0x5D, 0x0C, 0x05, 0x7C, 0x80, 0x27, 0x59, 0xF9, 0x62, 0x16, 0xA7, 0xBC, 0xC3, 0x12, 0x27, 0x92, - 0x30, 0x6A, 0x7E, 0x24, 0x4E, 0xC3, 0x7D, 0x80, 0xD4, 0x49, 0x0B, 0x08, 0x37, 0x44, 0x04, 0x10, - 0x04, 0x1D, 0x6A, 0x7F, 0x51, 0x64, 0x12, 0xFF, 0xD4, 0x7C, 0x36, 0x0A, 0xC0, 0xAD, 0x26, 0x80, - 0x6A, 0x59, 0x60, 0x40, 0x14, 0xD1, 0x2B, 0x78, 0xC4, 0xF1, 0x5C, 0x1B, 0x58, 0x76, 0x05, 0x66, - 0x5C, 0xC2, 0x7A, 0x5E, 0xC6, 0x8E, 0x3E, 0x16, 0x2B, 0x31, 0x53, 0x61, 0x00, 0xF1, 0x82, 0x32, - 0x1C, 0xB8, 0x70, 0x8C, 0x78, 0xE2, 0x15, 0x00, 0x42, 0xCC, 0x91, 0x1A, 0xB0, 0x5A, 0x71, 0x5C, - 0x38, 0x43, 0x31, 0x64, 0x90, 0x68, 0x58, 0x76, 0xBA, 0xCF, 0x12, 0x8A, 0x99, 0x00, 0xA9, 0x84, - 0xEF, 0x2D, 0x00, 0x00, 0x23, 0xB0, 0x3A, 0x69, 0xCC, 0x48, 0xFF, 0xFB, 0x92, 0x64, 0xE3, 0x8F, - 0x34, 0x75, 0x35, 0x4F, 0x03, 0x98, 0x7D, 0xA0, 0x30, 0x23, 0xCA, 0x0E, 0x08, 0x66, 0x68, 0x11, - 0xEC, 0xD3, 0x3A, 0x0E, 0x65, 0xEF, 0x80, 0xBE, 0x91, 0xA7, 0xD0, 0x60, 0x8C, 0xF0, 0x13, 0x53, - 0x07, 0x0A, 0x56, 0x12, 0xAA, 0x96, 0x85, 0x81, 0x8A, 0x94, 0x90, 0xAB, 0x59, 0x2F, 0x1D, 0xC5, - 0x45, 0x1D, 0x6B, 0x61, 0x45, 0x45, 0xB8, 0x46, 0xE5, 0x56, 0x90, 0xAE, 0x56, 0xA3, 0xAC, 0x22, - 0x49, 0xCC, 0x11, 0x13, 0xAC, 0xA1, 0x0E, 0x4A, 0x7C, 0xAE, 0x07, 0xFA, 0x8A, 0xA7, 0x3F, 0xF3, - 0xDC, 0x96, 0xF4, 0xDC, 0x72, 0x4C, 0xC8, 0x12, 0x21, 0x4C, 0x9C, 0x95, 0x05, 0x6C, 0x6F, 0xFC, - 0x9F, 0x9F, 0xDA, 0x7B, 0x2D, 0xD6, 0xC3, 0xCA, 0xAC, 0x09, 0xA1, 0x3B, 0x99, 0x80, 0x36, 0x00, - 0x03, 0xCB, 0xD5, 0xA3, 0x0C, 0x3F, 0x7F, 0xB2, 0xE6, 0xED, 0xFF, 0xA5, 0xFD, 0x7C, 0xF3, 0xBA, - 0xDC, 0x11, 0x90, 0x51, 0x2D, 0x90, 0x03, 0x0E, 0x22, 0x90, 0xD1, 0x23, 0x2B, 0x10, 0xBA, 0xF5, - 0x0A, 0x36, 0x30, 0x55, 0xFE, 0x9D, 0xFA, 0x8E, 0x45, 0xA9, 0x40, 0xC0, 0xD1, 0xB5, 0x3D, 0xB9, - 0x81, 0x80, 0xE1, 0x98, 0xC8, 0x20, 0x6F, 0x29, 0x88, 0x88, 0x47, 0x2C, 0x56, 0x98, 0xD5, 0x4C, - 0x62, 0xC0, 0x49, 0x99, 0x46, 0x86, 0x48, 0x1A, 0x9F, 0x6D, 0x28, 0x44, 0xEB, 0x30, 0x38, 0x80, - 0xFE, 0x65, 0x87, 0x1E, 0x52, 0x7C, 0xCA, 0x94, 0x61, 0xDE, 0x54, 0x3D, 0x5E, 0x2C, 0xD5, 0xD5, - 0x47, 0x27, 0x1A, 0xCB, 0x3B, 0x99, 0x60, 0x0B, 0x56, 0x5C, 0xFB, 0x3A, 0x6B, 0xAD, 0x30, 0x57, - 0xCA, 0x22, 0x55, 0x5E, 0x32, 0x37, 0x61, 0x9B, 0x21, 0xD9, 0x56, 0x97, 0xB9, 0xC3, 0x71, 0x99, - 0xBA, 0xEB, 0xB2, 0xBC, 0x10, 0x55, 0x7A, 0xFA, 0x83, 0x93, 0x11, 0x79, 0x35, 0x0B, 0x1A, 0xA9, - 0x00, 0x48, 0x63, 0xC8, 0x4A, 0x22, 0x5A, 0xAB, 0xB1, 0xDB, 0x71, 0xFA, 0x78, 0xC3, 0xE9, 0x1D, - 0xE5, 0xD8, 0xC4, 0x1B, 0x4A, 0xF5, 0x48, 0xD2, 0xAC, 0x20, 0xE8, 0xF2, 0xCB, 0x0B, 0xCA, 0xCB, - 0x12, 0x9A, 0x47, 0x9F, 0xEC, 0xBC, 0xF2, 0xF6, 0x30, 0xF3, 0x2B, 0xE5, 0xD0, 0xDB, 0xC5, 0xEA, - 0x70, 0xC2, 0xC1, 0x10, 0x0D, 0x19, 0xAA, 0x0A, 0x63, 0x3D, 0x94, 0x2C, 0x36, 0x31, 0xD4, 0xAE, - 0x73, 0x57, 0xA3, 0x59, 0x6B, 0xD5, 0x04, 0x95, 0xB6, 0x3A, 0x89, 0x43, 0x86, 0x8D, 0x0D, 0xFB, - 0x08, 0x06, 0x14, 0xE1, 0xCF, 0x55, 0x94, 0x00, 0x2F, 0x29, 0x37, 0xB1, 0xEA, 0x30, 0x03, 0x01, - 0x63, 0x06, 0x51, 0x25, 0x31, 0x76, 0x5B, 0x63, 0x02, 0x00, 0xDA, 0x33, 0x4E, 0xA4, 0xD4, 0x8B, - 0x33, 0x1E, 0x92, 0x0F, 0x46, 0xD4, 0x31, 0xB1, 0x6C, 0xC4, 0x04, 0xC3, 0x56, 0x97, 0x0C, 0x8A, - 0x1D, 0x32, 0x7F, 0x8D, 0xC9, 0x03, 0x22, 0x60, 0xD8, 0x83, 0x21, 0x26, 0x64, 0x43, 0x5C, 0x5E, - 0x12, 0x98, 0xD3, 0x37, 0x91, 0x32, 0x66, 0xBE, 0xED, 0x31, 0xC2, 0x50, 0xFF, 0xFB, 0x90, 0x64, - 0xE3, 0x8F, 0x14, 0xBD, 0x34, 0xCD, 0x03, 0xBB, 0xC8, 0xC0, 0x2C, 0xA4, 0x69, 0xD4, 0x24, 0x65, - 0x6C, 0x12, 0xF0, 0xD5, 0x30, 0x0E, 0xF3, 0x03, 0x00, 0xB1, 0x12, 0xE8, 0x24, 0x50, 0x9B, 0x0A, - 0x05, 0xE9, 0x41, 0x98, 0xF2, 0x65, 0x2A, 0x44, 0xF8, 0xA0, 0x51, 0x01, 0x18, 0xB4, 0x64, 0x66, - 0xEC, 0xA1, 0x52, 0x49, 0x58, 0x0D, 0x22, 0x22, 0xA5, 0x32, 0xB1, 0xB5, 0xE1, 0xE0, 0xEF, 0x02, - 0x87, 0x28, 0xCC, 0x06, 0xC5, 0x60, 0x35, 0x6C, 0x53, 0x56, 0xE6, 0x82, 0x46, 0x0E, 0xC1, 0xE4, - 0x94, 0x14, 0xC8, 0xF0, 0xDA, 0x40, 0x2C, 0x78, 0xC8, 0x80, 0x2F, 0xFB, 0x9B, 0x4C, 0xA3, 0xAB, - 0x08, 0xC6, 0xA4, 0xEE, 0x0D, 0x16, 0xB2, 0x80, 0x17, 0xB4, 0xD2, 0x93, 0x48, 0x74, 0x11, 0xAE, - 0x24, 0x28, 0x47, 0xA4, 0x43, 0x68, 0x16, 0xA1, 0x8A, 0x46, 0x96, 0xCE, 0x9C, 0x67, 0x6D, 0x7B, - 0xA9, 0x35, 0x84, 0x66, 0x52, 0xCB, 0xC1, 0x81, 0x50, 0x00, 0x09, 0x6A, 0x81, 0x87, 0xA6, 0x80, - 0xA4, 0xB3, 0x0C, 0xE8, 0x69, 0xB1, 0x29, 0x7C, 0x33, 0xFF, 0x53, 0xA4, 0x6A, 0xD7, 0xCA, 0x99, - 0xA7, 0x1D, 0xD4, 0xB0, 0x1A, 0xA5, 0xFB, 0x4A, 0x48, 0xB3, 0xB4, 0x99, 0xFF, 0xF2, 0xD4, 0xD0, - 0xA3, 0x89, 0x7F, 0xD3, 0x64, 0x01, 0x61, 0x60, 0x31, 0x30, 0x24, 0x10, 0x03, 0x40, 0x66, 0x4D, - 0x31, 0x25, 0x06, 0xE3, 0x04, 0x82, 0x17, 0x30, 0xFD, 0x07, 0x93, 0x0B, 0xA1, 0x4B, 0x25, 0x02, - 0x63, 0xB1, 0xA1, 0x38, 0x8A, 0xA0, 0xCF, 0xA3, 0x18, 0x7F, 0x33, 0xA2, 0x53, 0x06, 0x4A, 0x0C, - 0x7A, 0x0E, 0x01, 0x65, 0x41, 0xA5, 0x7D, 0xEC, 0x46, 0x9B, 0x83, 0x12, 0x78, 0xD3, 0xF9, 0xB3, - 0xAF, 0x17, 0xD4, 0x86, 0x08, 0x88, 0x93, 0x89, 0x30, 0x54, 0x01, 0x77, 0xD6, 0xC8, 0xA8, 0xDA, - 0xE2, 0x00, 0xCB, 0x21, 0x48, 0xC2, 0x99, 0x8C, 0xEC, 0xB6, 0x9D, 0xF6, 0x61, 0xCC, 0xBD, 0x86, - 0xAF, 0x87, 0x45, 0x8E, 0xAD, 0x77, 0xF9, 0xDA, 0x80, 0x92, 0xAD, 0x3F, 0xCB, 0x4C, 0x67, 0x31, - 0x5C, 0xD0, 0x61, 0x51, 0xD0, 0x0E, 0x35, 0x4F, 0xAA, 0x18, 0xFB, 0x90, 0xA3, 0xAD, 0x06, 0x1F, - 0x4A, 0xF4, 0xE1, 0x62, 0xF7, 0xA3, 0x2A, 0xCB, 0x3B, 0x28, 0xA4, 0x6C, 0x2D, 0xF5, 0x22, 0x62, - 0x2F, 0xC0, 0x21, 0xA1, 0xC5, 0xEC, 0xE5, 0xB3, 0xB2, 0xCA, 0x35, 0x06, 0x18, 0xB0, 0x88, 0x05, - 0x56, 0x86, 0xB2, 0x94, 0xAC, 0xBD, 0x3C, 0x17, 0x3B, 0xD1, 0x0D, 0x98, 0xDF, 0x27, 0xF8, 0x6A, - 0x93, 0x0C, 0x5E, 0xAB, 0xA7, 0x83, 0x47, 0xFB, 0x20, 0x7A, 0xAB, 0x18, 0xAA, 0xE8, 0xCF, 0xAA, - 0x76, 0x28, 0xC2, 0x10, 0x42, 0xE0, 0x3A, 0xBB, 0xDD, 0x37, 0x8C, 0xFD, 0xA9, 0x46, 0x1C, 0xD0, - 0xEE, 0xD1, 0xF3, 0xAF, 0x71, 0x19, 0xB4, 0xED, 0x7B, 0x40, 0xB3, 0x8A, 0xAF, 0x30, 0x10, 0x00, - 0xE3, 0x09, 0x51, 0x8F, 0x37, 0x9B, 0x4B, 0x23, 0x07, 0xF1, 0x3F, 0x32, 0x90, 0xFF, 0xFB, 0x92, - 0x64, 0xDE, 0x0F, 0x75, 0x2B, 0x34, 0xCA, 0x83, 0xDC, 0xD0, 0xB0, 0x30, 0x05, 0xB9, 0xA4, 0x08, - 0xC3, 0x50, 0x54, 0x98, 0xD1, 0x28, 0x0F, 0x6F, 0x06, 0x80, 0xC7, 0x17, 0x25, 0x94, 0x11, 0x99, - 0x29, 0xC3, 0x36, 0x8C, 0x1E, 0x30, 0xE8, 0x7F, 0x38, 0xF8, 0x58, 0x35, 0x88, 0x10, 0x32, 0xB8, - 0x7E, 0x36, 0xC4, 0x06, 0x69, 0x83, 0xC0, 0x89, 0x3E, 0x38, 0x2E, 0xD5, 0x0A, 0x33, 0x1B, 0x90, - 0xF2, 0x19, 0x33, 0x96, 0xC0, 0xD0, 0x31, 0xE4, 0x7B, 0x18, 0x3B, 0x1A, 0x75, 0x95, 0x58, 0x1C, - 0x3D, 0x22, 0x4B, 0x88, 0x48, 0x01, 0x6A, 0xBB, 0x0E, 0xBA, 0x8B, 0x27, 0xBA, 0x4E, 0xCF, 0x3A, - 0x0F, 0xBF, 0x72, 0xEF, 0xED, 0xBA, 0xB8, 0xC9, 0x22, 0x59, 0x64, 0xAF, 0x58, 0x74, 0xE8, 0x49, - 0x96, 0x22, 0xC0, 0x64, 0xE8, 0xF3, 0x24, 0x72, 0xCB, 0x93, 0x23, 0xAC, 0xAA, 0xEC, 0xEA, 0x17, - 0x29, 0x96, 0x3A, 0xAB, 0xE2, 0x00, 0x46, 0xE5, 0x9E, 0x9B, 0x05, 0xAE, 0xA2, 0x56, 0x59, 0xD7, - 0x4E, 0xF3, 0xA7, 0x49, 0x2A, 0x68, 0x44, 0x42, 0x4B, 0x4C, 0x04, 0x0A, 0xC2, 0x52, 0x49, 0xA8, - 0x38, 0xE1, 0x60, 0x6E, 0x50, 0x70, 0x25, 0x81, 0xB0, 0xC5, 0xDB, 0xB3, 0x8D, 0x05, 0xC3, 0xD0, - 0xD3, 0x2C, 0xCC, 0x18, 0xAB, 0x20, 0x00, 0x33, 0x83, 0x43, 0xA4, 0x3E, 0xD4, 0x67, 0x2F, 0x43, - 0x2C, 0xB2, 0x63, 0x03, 0xDD, 0x90, 0x4D, 0xEF, 0x9F, 0xFF, 0xF5, 0x03, 0x0B, 0xA9, 0x12, 0x33, - 0xD6, 0x7F, 0x1F, 0x6C, 0x6E, 0x5D, 0x63, 0x54, 0x8F, 0x1F, 0x06, 0x13, 0x6D, 0xEC, 0xB0, 0x60, - 0x02, 0x03, 0x46, 0x19, 0xC0, 0xC2, 0x74, 0x70, 0x89, 0x26, 0x15, 0x40, 0xD4, 0x62, 0x6A, 0x21, - 0xE6, 0x77, 0xE1, 0x72, 0x60, 0x78, 0x10, 0x66, 0x3A, 0x63, 0xAE, 0x63, 0x40, 0x27, 0xE4, 0x3E, - 0x4F, 0x0E, 0x64, 0x44, 0x66, 0x95, 0x2E, 0x62, 0x62, 0x42, 0x4E, 0x63, 0x40, 0xE5, 0xE4, 0x32, - 0x24, 0x06, 0xE7, 0x11, 0x72, 0xC7, 0x06, 0xA0, 0x33, 0xB1, 0x24, 0x0E, 0xB4, 0xA2, 0xA8, 0x1C, - 0x80, 0xA0, 0x14, 0x8B, 0xD8, 0x15, 0x08, 0x91, 0x41, 0x09, 0x04, 0x19, 0x54, 0x51, 0xC5, 0x2F, - 0x97, 0xDA, 0x11, 0x37, 0x78, 0x3E, 0xA7, 0x3F, 0xEC, 0x97, 0x19, 0x4E, 0x51, 0x1B, 0x6B, 0x59, - 0xA4, 0x20, 0x09, 0xF4, 0x5A, 0xAA, 0xDB, 0x2E, 0x75, 0xD3, 0xAD, 0xBF, 0x49, 0xE8, 0xBA, 0xFA, - 0x87, 0x5F, 0xEE, 0x6A, 0x34, 0xF1, 0xBE, 0x8E, 0x05, 0xEA, 0xF6, 0xA2, 0xAE, 0x8A, 0xE1, 0x75, - 0x50, 0x8D, 0xAC, 0xA8, 0x04, 0xEC, 0xF0, 0x54, 0x2D, 0x3A, 0x6D, 0x0A, 0xD5, 0xE2, 0x1A, 0xA3, - 0xD2, 0xF4, 0x1A, 0xBB, 0x30, 0xA9, 0xB9, 0xC5, 0xE8, 0xDA, 0x17, 0xED, 0x97, 0x30, 0xF4, 0xE1, - 0xC1, 0xC0, 0x00, 0x01, 0x00, 0xB4, 0x1C, 0x08, 0x9A, 0x76, 0x08, 0xD4, 0x09, 0xD4, 0x6A, 0x68, - 0x47, 0x6D, 0xCA, 0x5D, 0xCA, 0x28, 0x85, 0xF1, 0x35, 0x98, 0x39, 0xBF, 0xBD, 0x41, 0xA5, 0xFF, - 0xFB, 0x92, 0x64, 0xC7, 0x0F, 0x35, 0x0E, 0x34, 0xCA, 0x83, 0xDD, 0xD0, 0xA0, 0x2C, 0x22, 0x49, - 0xA4, 0x08, 0x23, 0x0A, 0x54, 0x3C, 0xD3, 0x28, 0x0F, 0x6F, 0x06, 0xC0, 0xBC, 0x07, 0xA6, 0xD0, - 0xF3, 0x08, 0x59, 0xF8, 0x72, 0x63, 0x3D, 0xFC, 0x3F, 0xFD, 0x7F, 0x2F, 0x31, 0x0D, 0x53, 0xEA, - 0x5A, 0x6D, 0x9A, 0x29, 0x30, 0x04, 0x02, 0x63, 0x0A, 0x51, 0x5C, 0x3A, 0x0F, 0x46, 0x43, 0x10, - 0xA0, 0xF8, 0x11, 0xDF, 0xA7, 0xE6, 0x87, 0x06, 0x1C, 0x9F, 0x26, 0xDF, 0x06, 0x07, 0x02, 0x9D, - 0x06, 0x51, 0x07, 0xE7, 0x02, 0x9D, 0x66, 0x09, 0x86, 0x44, 0xA5, 0x80, 0x34, 0x0B, 0x0C, 0x04, - 0x41, 0xC9, 0x92, 0xAC, 0x3C, 0xD8, 0x71, 0x55, 0xD1, 0x06, 0x3A, 0x8E, 0x12, 0xE8, 0x01, 0x12, - 0x21, 0x12, 0xC0, 0xC2, 0xA3, 0xA3, 0xF0, 0x16, 0xCD, 0xC8, 0x36, 0x0C, 0x44, 0xC0, 0x30, 0x6E, - 0x02, 0x13, 0x14, 0x18, 0x58, 0xF5, 0x9B, 0x1D, 0x7B, 0xA3, 0x52, 0x0E, 0xD6, 0x5E, 0x66, 0xAA, - 0x26, 0x48, 0x4A, 0x22, 0xC7, 0x13, 0xE0, 0x90, 0x26, 0xE4, 0x5A, 0xE2, 0xE2, 0xA4, 0x63, 0x38, - 0x1E, 0x26, 0x38, 0x9C, 0x45, 0x64, 0x38, 0xEF, 0x63, 0xE4, 0xEE, 0xE3, 0xB9, 0x87, 0xF7, 0x08, - 0x94, 0x35, 0x3D, 0x29, 0xFA, 0x8F, 0xBB, 0x5A, 0x9E, 0x61, 0x0C, 0xEE, 0x5A, 0xDC, 0x10, 0x14, - 0xDF, 0x2B, 0x2A, 0x6B, 0x4B, 0x26, 0xD2, 0xFD, 0xE7, 0x0C, 0x69, 0x46, 0x9C, 0xDA, 0xB1, 0x36, - 0xB6, 0x91, 0xE9, 0x8A, 0x89, 0xC9, 0xD7, 0x01, 0x9E, 0xFF, 0xFA, 0x47, 0xA0, 0x00, 0x01, 0x00, - 0x00, 0x00, 0xA0, 0x75, 0x4E, 0x86, 0xC7, 0xA6, 0xB0, 0x0E, 0x0C, 0x48, 0x7C, 0x99, 0x43, 0xDD, - 0x76, 0xF1, 0x61, 0xCE, 0x0C, 0xB6, 0x20, 0x20, 0xB2, 0x60, 0x27, 0xEE, 0x40, 0x85, 0xE0, 0x3B, - 0xD1, 0x3F, 0xC8, 0x57, 0x3A, 0xA7, 0x15, 0xB4, 0xD3, 0x19, 0xA3, 0xFF, 0xFE, 0xA0, 0x08, 0x2E, - 0x18, 0x17, 0x05, 0xE9, 0xC4, 0x52, 0x5D, 0x98, 0x54, 0x85, 0x41, 0x85, 0xE1, 0xF6, 0x99, 0x1F, - 0x87, 0x61, 0x00, 0x2F, 0x18, 0x9A, 0xA2, 0xC1, 0xC0, 0x06, 0x61, 0x9A, 0x2D, 0xE9, 0xCC, 0xA4, - 0x81, 0x81, 0xA1, 0x29, 0x9C, 0x08, 0xF1, 0x28, 0xE6, 0x64, 0x08, 0x18, 0x07, 0x2C, 0xB0, 0x85, - 0x5B, 0xBB, 0x69, 0x81, 0x51, 0x57, 0x09, 0x50, 0x32, 0xF7, 0x4C, 0xCB, 0x89, 0x94, 0xA2, 0x19, - 0xA9, 0x02, 0x9B, 0xC6, 0x4E, 0xB0, 0xF1, 0xD1, 0x01, 0x43, 0xE8, 0x69, 0x55, 0xCC, 0xB1, 0x04, - 0x48, 0x45, 0x40, 0xCF, 0xA3, 0xC6, 0x4B, 0xDC, 0xE2, 0x38, 0x08, 0xE1, 0x21, 0x9A, 0x9D, 0x2F, - 0xBA, 0xC2, 0x18, 0x85, 0xC3, 0x4A, 0x49, 0x9E, 0x0B, 0x1C, 0x00, 0x81, 0x41, 0x46, 0x9A, 0xD6, - 0x1A, 0x5A, 0xF6, 0x52, 0xF1, 0x80, 0x0B, 0x69, 0xAA, 0xEA, 0x6A, 0x0E, 0xCB, 0xBF, 0x04, 0x51, - 0xE5, 0x8E, 0xF5, 0xFF, 0x5A, 0xD5, 0x58, 0x79, 0x8D, 0x26, 0xA4, 0xE3, 0xEF, 0x06, 0xAE, 0x55, - 0x0D, 0xFF, 0xFB, 0x92, 0x64, 0xB6, 0x8F, 0x15, 0x3A, 0x34, 0x49, 0x83, 0xDD, 0xC8, 0xC0, 0x32, - 0x41, 0x29, 0xDD, 0x64, 0x29, 0x10, 0x15, 0x94, 0xD7, 0x26, 0x0F, 0x77, 0x46, 0x80, 0xA7, 0x0C, - 0xA7, 0x8C, 0xC4, 0x8C, 0x20, 0x59, 0xB7, 0xD3, 0x31, 0xAF, 0x96, 0xFD, 0xCF, 0x51, 0xC8, 0xAC, - 0xB1, 0x86, 0x21, 0x1B, 0x8A, 0x2C, 0x19, 0xCD, 0x31, 0xA0, 0xD6, 0x34, 0xE5, 0xBE, 0x00, 0x05, - 0x4C, 0x13, 0x04, 0xBF, 0xB4, 0x28, 0x55, 0x0F, 0x8A, 0x52, 0x1F, 0x50, 0x38, 0x49, 0xF3, 0xB5, - 0x32, 0x1E, 0x32, 0xEC, 0xE2, 0x04, 0x13, 0x96, 0x5E, 0x7C, 0xA8, 0x3A, 0x5C, 0xDD, 0xEF, 0xD4, - 0x7E, 0x77, 0x16, 0xB0, 0x7B, 0xD4, 0x47, 0xD2, 0x30, 0x10, 0x09, 0x31, 0x54, 0x96, 0x3E, 0xA7, - 0xD0, 0x30, 0xD4, 0x75, 0x30, 0xF2, 0x5B, 0x3A, 0x80, 0xF0, 0x31, 0x40, 0x91, 0x38, 0xB6, 0x15, - 0x35, 0x58, 0x75, 0x31, 0x7C, 0x01, 0x36, 0x18, 0xA0, 0x30, 0xA0, 0x0F, 0x38, 0x79, 0xC3, 0x66, - 0x13, 0x36, 0x65, 0x03, 0x28, 0x04, 0x81, 0xC5, 0x54, 0xC4, 0x82, 0x9A, 0x08, 0x88, 0x0D, 0xAC, - 0x32, 0xA1, 0xE0, 0x76, 0xBE, 0x44, 0x2B, 0x4E, 0xB0, 0x60, 0xA2, 0x06, 0x92, 0x60, 0xA3, 0x23, - 0xCB, 0x29, 0x28, 0x68, 0x25, 0x6C, 0x50, 0xB0, 0x6C, 0x2C, 0x70, 0xE6, 0x18, 0x48, 0xEA, 0x9C, - 0xB0, 0x98, 0x72, 0x09, 0x4C, 0xBB, 0x3F, 0xB0, 0xB0, 0x61, 0x85, 0x42, 0x18, 0x71, 0x38, 0x38, - 0x6C, 0xC5, 0x42, 0x02, 0x05, 0x0B, 0x92, 0x1C, 0x13, 0x68, 0xBD, 0x0C, 0x5D, 0x98, 0xA7, 0x33, - 0x76, 0x7D, 0xA7, 0x39, 0x5A, 0xCF, 0xFF, 0xCD, 0x4F, 0xFF, 0xFF, 0xFF, 0xFF, 0xE5, 0xD8, 0x31, - 0xA7, 0xF1, 0xA2, 0xA2, 0xDB, 0x61, 0x0E, 0x22, 0xF7, 0x41, 0x20, 0x5C, 0x0E, 0xE8, 0x28, 0x2A, - 0x4D, 0xA3, 0x3C, 0xF5, 0x29, 0x94, 0x45, 0xE2, 0x40, 0x72, 0x6A, 0xA8, 0x09, 0xDC, 0xB8, 0x04, - 0x80, 0x00, 0x10, 0x03, 0x8A, 0x21, 0x95, 0xBC, 0x26, 0x17, 0x90, 0x1C, 0x03, 0x8D, 0xC9, 0xBF, - 0xC6, 0xE6, 0x2B, 0x34, 0xFD, 0x55, 0x8F, 0x1D, 0x9F, 0x71, 0x7D, 0xFF, 0x83, 0x70, 0xB9, 0x62, - 0xEE, 0x43, 0x49, 0x68, 0xFF, 0xD5, 0x48, 0x50, 0x58, 0xA3, 0x96, 0xD9, 0x45, 0x10, 0x08, 0x5C, - 0x02, 0x30, 0x60, 0x63, 0x33, 0x71, 0xD3, 0x0B, 0x17, 0x26, 0x05, 0x80, 0x26, 0xCA, 0x02, 0x60, - 0x00, 0xC4, 0xC2, 0xC8, 0x64, 0x14, 0xE9, 0x02, 0x87, 0x13, 0x1B, 0xCC, 0x10, 0x50, 0x22, 0x62, - 0x85, 0x84, 0x71, 0x7D, 0x42, 0x84, 0x61, 0x62, 0x00, 0x26, 0x4C, 0x0E, 0x0D, 0x21, 0x97, 0xD0, - 0xAB, 0x74, 0xB1, 0x65, 0x27, 0xBC, 0x08, 0x54, 0x06, 0x96, 0x48, 0x4D, 0x32, 0x43, 0x0A, 0x04, - 0x4C, 0x84, 0x17, 0x40, 0x51, 0x8E, 0x1A, 0xB3, 0xD9, 0xD3, 0x24, 0xAD, 0x6D, 0xAF, 0x4C, 0x5B, - 0xDE, 0x23, 0xA1, 0x0C, 0xB9, 0x43, 0x5B, 0x1C, 0x5A, 0x5A, 0x00, 0x51, 0x31, 0xBD, 0x59, 0x8A, - 0xF5, 0x1B, 0x33, 0xFF, 0xFB, 0x92, 0x64, 0x9D, 0x8D, 0x75, 0x39, 0x34, 0xCB, 0x03, 0xBB, 0xC2, - 0xF0, 0x2E, 0xE3, 0x99, 0xB8, 0x19, 0x48, 0x16, 0x11, 0xA0, 0xD5, 0x36, 0x2E, 0xE9, 0xEB, 0xD0, - 0xC4, 0x15, 0xE6, 0xE0, 0xD4, 0x8A, 0x21, 0x12, 0x12, 0xA7, 0x40, 0x38, 0x6E, 0xFF, 0xFF, 0x6D, - 0xFC, 0xFF, 0xFF, 0xFE, 0x8D, 0xF8, 0xBB, 0xC6, 0x06, 0x13, 0x19, 0x89, 0x0E, 0x23, 0x29, 0x81, - 0xF8, 0x7D, 0xC2, 0x8D, 0xCC, 0x07, 0x23, 0xF0, 0x35, 0x28, 0xD1, 0x3B, 0x21, 0xEB, 0x7A, 0x03, - 0x18, 0x1B, 0x8D, 0x7D, 0x4E, 0x93, 0xD4, 0x25, 0xA7, 0x8B, 0x2B, 0x4B, 0xC9, 0x26, 0xA5, 0x9E, - 0xB3, 0xA4, 0x80, 0x8F, 0x57, 0x6F, 0xC7, 0xF8, 0x7F, 0xFD, 0x0A, 0xC5, 0x28, 0xCF, 0x09, 0xAE, - 0x05, 0x8A, 0xE5, 0xFA, 0x9F, 0xFF, 0xFA, 0x17, 0x86, 0x8A, 0x74, 0x7B, 0x7C, 0xE5, 0xC0, 0xB3, - 0x2D, 0x49, 0xDE, 0xC9, 0xAA, 0x8C, 0xC1, 0x8E, 0x27, 0x91, 0x8C, 0xA6, 0x31, 0xC3, 0x29, 0x49, - 0x8B, 0x60, 0xB9, 0x8D, 0xD3, 0x79, 0xCB, 0x20, 0x41, 0x85, 0x64, 0x99, 0xA1, 0x40, 0x98, 0xD3, - 0x14, 0x1D, 0xC4, 0x23, 0x81, 0xC2, 0x4A, 0x6B, 0x09, 0xAD, 0xF8, 0xE9, 0x81, 0x28, 0xDA, 0xB2, - 0xA1, 0xA0, 0xCD, 0x2C, 0x50, 0x3A, 0x90, 0x52, 0xB0, 0xA0, 0x67, 0xF0, 0x42, 0x4D, 0x06, 0x9A, - 0x31, 0xA1, 0x14, 0x3D, 0x42, 0x28, 0x23, 0x31, 0x42, 0x42, 0x48, 0xCF, 0x81, 0x6F, 0x88, 0x84, - 0x2E, 0x08, 0xCA, 0x82, 0x39, 0x9D, 0xC2, 0xD2, 0x0C, 0x34, 0xA2, 0x53, 0xA0, 0xC8, 0x45, 0x06, - 0x04, 0x61, 0x45, 0x96, 0x2C, 0xC4, 0x39, 0xA9, 0x55, 0xBA, 0x89, 0xF4, 0xEC, 0xBA, 0x96, 0xAE, - 0xDF, 0x86, 0x3B, 0xFF, 0xFF, 0xFA, 0xE7, 0xE7, 0xAF, 0xFD, 0x71, 0xAA, 0xC3, 0xD8, 0xB1, 0x88, - 0x06, 0xC2, 0x29, 0x4B, 0x52, 0x79, 0xDA, 0x67, 0x63, 0x00, 0xDF, 0xAD, 0xFF, 0x21, 0xA7, 0x95, - 0xB9, 0x44, 0xDF, 0x88, 0x93, 0x0A, 0x95, 0x74, 0x20, 0x80, 0x01, 0x81, 0x49, 0x5E, 0xE7, 0xFF, - 0xFE, 0xF6, 0x0A, 0x12, 0x8F, 0x6D, 0xC6, 0x69, 0x82, 0xF3, 0xFE, 0x02, 0xC3, 0x80, 0x54, 0xB3, - 0x49, 0x7A, 0xDE, 0x9C, 0x47, 0xF5, 0x6A, 0x24, 0x92, 0x3C, 0xE2, 0x3E, 0x40, 0x53, 0x27, 0xFF, - 0xD6, 0x48, 0x0B, 0x1A, 0x52, 0x20, 0x2E, 0x77, 0xA7, 0x45, 0x8E, 0xAA, 0x66, 0x20, 0x2D, 0x9F, - 0x26, 0x98, 0x68, 0xC2, 0xF1, 0x22, 0xAC, 0xFB, 0xB6, 0xA3, 0x01, 0x81, 0x8C, 0x91, 0xD7, 0x3C, - 0xEC, 0x5F, 0x32, 0x68, 0x4B, 0x32, 0x41, 0xAE, 0x31, 0x8C, 0x30, 0x04, 0x08, 0x3E, 0xB0, 0xCD, - 0xA9, 0xB3, 0x10, 0x44, 0x58, 0xF2, 0x16, 0xAB, 0xA5, 0x23, 0x06, 0xA9, 0x08, 0xAB, 0x3F, 0x44, - 0x56, 0x62, 0xE3, 0x3E, 0x62, 0x81, 0x40, 0xCD, 0x54, 0x34, 0xC3, 0x0D, 0x1B, 0x02, 0xC3, 0x53, - 0x8C, 0xAC, 0x22, 0xA6, 0x11, 0x08, 0x86, 0x1D, 0x26, 0x3B, 0x28, 0x71, 0x98, 0xA6, 0x7F, 0x2A, - 0x20, 0x2C, 0x0E, 0x05, 0x23, 0xFF, 0xFB, 0x92, 0x64, 0x92, 0x8F, 0x54, 0xBE, 0x35, 0x4C, 0x03, - 0x3D, 0xD0, 0x40, 0x33, 0x26, 0x99, 0x88, 0x18, 0x23, 0xD4, 0x12, 0x88, 0xD5, 0x30, 0x0E, 0x77, - 0x46, 0x40, 0xB8, 0x98, 0xE5, 0xE0, 0x24, 0x09, 0x79, 0x10, 0x5B, 0x0E, 0x32, 0xE3, 0xA7, 0xEC, - 0xB4, 0x64, 0x19, 0x12, 0xCC, 0xEF, 0x43, 0xB9, 0x44, 0x5C, 0xC9, 0x14, 0xFC, 0xFE, 0x1F, 0xFF, - 0xFF, 0x72, 0xDD, 0x7A, 0x1A, 0xF5, 0xFB, 0xBC, 0x6E, 0xC1, 0x36, 0x22, 0x4D, 0x9E, 0x99, 0xDF, - 0x81, 0x60, 0x27, 0xE5, 0xBC, 0xE5, 0xBC, 0x77, 0x4F, 0x28, 0x86, 0xBB, 0x2D, 0x49, 0x15, 0xF8, - 0xD8, 0x5B, 0xCE, 0x80, 0x18, 0x02, 0x98, 0xDF, 0xEB, 0x2B, 0xEF, 0x10, 0x6C, 0x1F, 0x94, 0x51, - 0x09, 0xC0, 0x56, 0xBE, 0x38, 0x7F, 0xE8, 0xE1, 0xEB, 0xF8, 0x71, 0x05, 0x97, 0xDF, 0x1C, 0x88, - 0xEC, 0x30, 0x96, 0xFF, 0xEA, 0xDD, 0x06, 0xA8, 0x77, 0x17, 0x48, 0xEB, 0x91, 0x81, 0x22, 0x70, - 0x46, 0xAA, 0x55, 0x22, 0x50, 0x24, 0xD3, 0x49, 0xBC, 0xC0, 0x52, 0xEC, 0xC2, 0xC1, 0xE4, 0xE5, - 0x00, 0x7C, 0xC6, 0x21, 0x50, 0xC0, 0xB9, 0x04, 0xE5, 0xB2, 0x58, 0xC1, 0xB2, 0x3C, 0x1A, 0x1A, - 0x00, 0x86, 0x83, 0x01, 0x40, 0x63, 0x35, 0x0D, 0x23, 0x14, 0x03, 0x13, 0x6F, 0x51, 0xA7, 0xE1, - 0x60, 0x92, 0xE0, 0x9D, 0x52, 0xA4, 0xE2, 0x12, 0x46, 0x81, 0x59, 0x69, 0x6E, 0xB2, 0xDE, 0x02, - 0x60, 0xDF, 0x47, 0x4C, 0x8B, 0x15, 0xF8, 0x23, 0x3D, 0x11, 0x04, 0x20, 0x83, 0x05, 0xB2, 0x02, - 0x1A, 0x67, 0x07, 0x8D, 0xB5, 0xCB, 0xEC, 0x0A, 0x99, 0x19, 0x0B, 0x12, 0x33, 0xFB, 0x4E, 0x01, - 0x18, 0x28, 0xC4, 0x14, 0x26, 0xA0, 0x04, 0x8E, 0xB1, 0xD6, 0x6E, 0x3B, 0xBA, 0x1E, 0x94, 0x7E, - 0x74, 0xEB, 0xFF, 0xFE, 0x27, 0x93, 0x31, 0x5E, 0xAD, 0xD7, 0xE5, 0x10, 0xA7, 0x5B, 0x6E, 0xBB, - 0x0C, 0x56, 0x52, 0x81, 0x22, 0x5E, 0xA3, 0x66, 0x01, 0xD0, 0xD4, 0x73, 0xAB, 0xE2, 0x88, 0x12, - 0x21, 0x16, 0xB2, 0x00, 0x00, 0x70, 0x00, 0x00, 0x04, 0x06, 0x00, 0xDD, 0x63, 0x00, 0x83, 0x1D, - 0x32, 0x11, 0x3B, 0xD1, 0xA4, 0x88, 0x3A, 0x9E, 0x7A, 0xBF, 0x40, 0x10, 0xA1, 0x00, 0x40, 0xE0, - 0x70, 0x0E, 0x5C, 0x0F, 0xDF, 0xF2, 0x78, 0x46, 0xD5, 0x82, 0x11, 0xF6, 0xBB, 0xFF, 0xC9, 0xFC, - 0x4E, 0xF0, 0x81, 0xC4, 0x20, 0x04, 0x0C, 0x11, 0x92, 0x84, 0x42, 0x69, 0x85, 0x26, 0xB1, 0x87, - 0xC7, 0xE9, 0x86, 0xE3, 0x11, 0x96, 0xF8, 0xC9, 0xCD, 0xA2, 0x39, 0x80, 0xC5, 0xA9, 0x9B, 0x40, - 0x41, 0x82, 0x00, 0x79, 0x82, 0x49, 0x81, 0x94, 0x0B, 0x69, 0x8F, 0x21, 0x31, 0x85, 0x42, 0x60, - 0xD0, 0x24, 0x59, 0x63, 0x90, 0x48, 0x9D, 0x04, 0xB5, 0xF3, 0x14, 0x55, 0x24, 0x50, 0xE6, 0x06, - 0x29, 0x7C, 0xA4, 0x2A, 0x41, 0x23, 0xB0, 0x8C, 0x14, 0xE8, 0x67, 0xA6, 0x38, 0x4B, 0x95, 0x6A, - 0x8D, 0x3D, 0x01, 0x3C, 0x90, 0xE6, 0x51, 0xFF, 0xFB, 0x92, 0x64, 0x8A, 0x8E, 0x84, 0x87, 0x34, - 0xCC, 0x03, 0xB9, 0x7B, 0x60, 0x2E, 0xA3, 0x79, 0xCD, 0x04, 0x05, 0x08, 0x13, 0x28, 0xD3, 0x30, - 0x4E, 0xE5, 0xEF, 0x90, 0xBA, 0x8F, 0x27, 0x68, 0x10, 0x18, 0x20, 0xDA, 0x2C, 0xB0, 0xAC, 0xF0, - 0x25, 0xD9, 0xA3, 0xE9, 0xA6, 0xA2, 0x45, 0x99, 0x61, 0x9B, 0x08, 0x82, 0x1A, 0x27, 0x65, 0xDD, - 0x80, 0xD3, 0x39, 0xBB, 0x49, 0xEA, 0xBF, 0x8E, 0xB5, 0xC9, 0x7E, 0xFF, 0xFF, 0xFF, 0xFD, 0xA5, - 0x7D, 0x4A, 0x65, 0x4E, 0x5B, 0xDC, 0x62, 0xFC, 0xC5, 0x4B, 0x1B, 0x47, 0x3A, 0x6F, 0x3D, 0xB8, - 0xC3, 0xA4, 0xE8, 0x95, 0xF2, 0xE2, 0x1F, 0x82, 0xE7, 0x1D, 0xDF, 0xFF, 0x49, 0xE5, 0xA7, 0x00, - 0x00, 0x00, 0x07, 0x00, 0xDF, 0xEF, 0x64, 0x4E, 0x49, 0x7D, 0x99, 0xE6, 0x90, 0x99, 0x55, 0x52, - 0x0B, 0x33, 0xE4, 0xDB, 0x57, 0x8D, 0xFF, 0xBD, 0x1A, 0x12, 0xE4, 0x1D, 0xF1, 0xD4, 0x95, 0x3E, - 0x4B, 0xEB, 0xEE, 0xC8, 0xBA, 0xB5, 0x4C, 0x7F, 0xF9, 0x5A, 0x1A, 0xC1, 0x72, 0x35, 0x04, 0x80, - 0x4B, 0xB8, 0xC5, 0x97, 0xC4, 0x74, 0x82, 0x31, 0xBC, 0xF4, 0x35, 0x94, 0x14, 0x31, 0x6C, 0x24, - 0x32, 0x72, 0x06, 0x38, 0x3C, 0xA2, 0x2E, 0x89, 0x90, 0x65, 0x68, 0x50, 0x1C, 0x31, 0x41, 0xD4, - 0x39, 0xCD, 0xD4, 0x30, 0x00, 0x9F, 0x36, 0xB5, 0x15, 0x31, 0x84, 0x09, 0x30, 0xA0, 0x18, 0x08, - 0xBA, 0x0E, 0x06, 0x18, 0x4A, 0x2A, 0x42, 0x24, 0x14, 0xA9, 0x4D, 0x03, 0x9C, 0x28, 0xDA, 0x47, - 0x96, 0xB9, 0xA1, 0xA7, 0x50, 0x60, 0xE1, 0x18, 0xF0, 0x08, 0xA6, 0x7A, 0x0D, 0x0E, 0x24, 0x19, - 0x09, 0x40, 0xE6, 0x69, 0x0E, 0xF9, 0x67, 0xBF, 0xFF, 0xC9, 0x46, 0x84, 0x96, 0x1D, 0x12, 0x80, - 0x52, 0x20, 0xA7, 0x42, 0x84, 0x04, 0xB0, 0x87, 0x25, 0x30, 0x89, 0x0D, 0x21, 0xF5, 0xA6, 0xF7, - 0xC0, 0xFD, 0xDC, 0x41, 0xAA, 0x39, 0xB0, 0x0C, 0xF3, 0x7F, 0xA9, 0x16, 0x4A, 0x98, 0xCC, 0x66, - 0x22, 0x5A, 0xA2, 0x08, 0xE4, 0x05, 0xA8, 0x2D, 0x65, 0xCC, 0xCC, 0x2D, 0x4B, 0x1D, 0xA1, 0xBA, - 0x88, 0x96, 0x88, 0x51, 0x98, 0x6F, 0x60, 0x40, 0x00, 0x03, 0x13, 0xF9, 0xC8, 0xBD, 0x55, 0x89, - 0xB5, 0x80, 0xEF, 0xDC, 0x54, 0xD6, 0x18, 0xB6, 0xC2, 0xC3, 0xC1, 0x56, 0xC0, 0xB4, 0x60, 0x62, - 0x38, 0xBF, 0x86, 0xB8, 0x69, 0x36, 0xB4, 0x71, 0xA2, 0x85, 0xEA, 0x56, 0xFF, 0xEC, 0xFA, 0x1C, - 0x3F, 0xCC, 0x6D, 0x06, 0x37, 0x60, 0x56, 0x10, 0xD2, 0xED, 0x04, 0x81, 0x66, 0xA6, 0x30, 0x06, - 0x21, 0x80, 0x66, 0x13, 0x0F, 0x06, 0x96, 0x89, 0x26, 0x10, 0x8E, 0x67, 0x2E, 0xEF, 0x06, 0x71, - 0x0C, 0x06, 0x37, 0x91, 0x82, 0xD2, 0xF0, 0x10, 0x04, 0x32, 0xCD, 0x82, 0x31, 0x44, 0x0D, 0x30, - 0xCC, 0x51, 0x35, 0x52, 0x58, 0x01, 0x14, 0x86, 0x08, 0x97, 0x86, 0x8C, 0xA8, 0x8C, 0x81, 0xD0, - 0x08, 0xEA, 0x18, 0x03, 0x8A, 0xE1, 0x59, 0x8C, 0xE9, 0xFF, 0xFB, 0x92, 0x64, 0x85, 0x8F, 0x54, - 0xC4, 0x35, 0x4B, 0x83, 0xBA, 0x6B, 0xE0, 0x32, 0x26, 0x49, 0x55, 0x09, 0x05, 0x6C, 0x53, 0xCC, - 0xD1, 0x2E, 0x0E, 0xEA, 0x2F, 0x88, 0xB6, 0x19, 0xE5, 0x60, 0xD3, 0x29, 0xD9, 0x57, 0x7C, 0x31, - 0x22, 0x17, 0xB3, 0x34, 0x23, 0x5D, 0x64, 0x27, 0xC7, 0x40, 0xB2, 0x83, 0x18, 0x51, 0x75, 0x37, - 0x54, 0xC2, 0x86, 0xE5, 0x90, 0xE6, 0xB1, 0xCA, 0xB5, 0x2A, 0x77, 0x28, 0x90, 0x14, 0x49, 0xCC, - 0x90, 0x8E, 0x63, 0x91, 0x03, 0xB5, 0x98, 0x82, 0xE6, 0xC5, 0xD0, 0x30, 0x32, 0x51, 0x19, 0xC0, - 0xCD, 0x5A, 0xCD, 0x48, 0x83, 0x69, 0x02, 0xB3, 0x0B, 0x67, 0xBF, 0xE6, 0xC3, 0xB4, 0x89, 0x11, - 0x35, 0xA4, 0x20, 0x29, 0x7D, 0x09, 0xA0, 0xC3, 0x11, 0xF9, 0x3F, 0x2E, 0xA0, 0xB4, 0x46, 0xC2, - 0x22, 0x10, 0x0C, 0xB8, 0xEA, 0x00, 0x00, 0x38, 0x00, 0x6C, 0x09, 0x00, 0x20, 0xAD, 0xBF, 0x10, - 0xE0, 0xE4, 0x47, 0xFF, 0xE9, 0xAB, 0x90, 0x8F, 0x06, 0x40, 0xE3, 0xEB, 0x9E, 0x82, 0x4F, 0x3C, - 0xA0, 0xF1, 0xDB, 0xD6, 0x4F, 0xE7, 0xAC, 0x80, 0x0B, 0x4E, 0xFF, 0xED, 0xFB, 0xF5, 0x24, 0xFA, - 0x64, 0x65, 0xB9, 0x53, 0x90, 0x9C, 0xB1, 0x3C, 0x35, 0x58, 0xC7, 0x0C, 0x9A, 0xA2, 0x56, 0x98, - 0x80, 0x06, 0x98, 0x22, 0x2B, 0x86, 0x54, 0xC6, 0x01, 0x12, 0x26, 0x29, 0x70, 0xA6, 0x7E, 0x0D, - 0x86, 0x39, 0x86, 0xE6, 0x79, 0x91, 0xC6, 0x17, 0x03, 0xE6, 0x11, 0xA9, 0x66, 0x15, 0x86, 0xE6, - 0x04, 0x97, 0x47, 0x18, 0x70, 0xE6, 0x29, 0x07, 0x86, 0x1C, 0x87, 0x62, 0xF6, 0xC1, 0x46, 0x00, - 0x53, 0xD3, 0xA8, 0x61, 0xD1, 0x12, 0x96, 0x32, 0x05, 0x68, 0xD7, 0x44, 0x25, 0x92, 0xFD, 0xD9, - 0x02, 0x28, 0x62, 0xA5, 0x43, 0xE1, 0x40, 0xCE, 0x89, 0xA1, 0x76, 0xBE, 0x15, 0x80, 0x38, 0x75, - 0x8B, 0x4A, 0x6F, 0xDE, 0x77, 0xFE, 0x6C, 0xCE, 0x8D, 0x66, 0xE2, 0x30, 0x87, 0x10, 0x31, 0x76, - 0x87, 0xBB, 0x00, 0x01, 0x9A, 0x83, 0x23, 0x41, 0x16, 0x18, 0xC0, 0x9B, 0x74, 0xFB, 0x5A, 0xDD, - 0x9C, 0x54, 0x7A, 0xC7, 0xFF, 0xFE, 0x1D, 0xFC, 0x3F, 0xEA, 0x67, 0x1A, 0x91, 0xE3, 0x12, 0x7E, - 0xA8, 0xF9, 0x94, 0xA0, 0x70, 0x3A, 0x4D, 0xBA, 0x13, 0x9F, 0xFA, 0xDA, 0x9B, 0xE4, 0xAA, 0x52, - 0x86, 0x10, 0x30, 0x15, 0xF4, 0x8C, 0xC2, 0x3A, 0x00, 0x44, 0x00, 0x40, 0x37, 0x08, 0x25, 0x0A, - 0xA7, 0xFF, 0x5F, 0x22, 0xF3, 0xD8, 0xED, 0x45, 0x0D, 0x90, 0xFF, 0x92, 0x2E, 0xF3, 0xCF, 0x99, - 0x7F, 0xFF, 0x0E, 0x10, 0xC4, 0xE0, 0x65, 0xEE, 0x40, 0xEF, 0xB2, 0x7C, 0xB8, 0xF7, 0xA3, 0x3E, - 0xFD, 0xE8, 0x28, 0xBC, 0xC1, 0x21, 0x83, 0xA7, 0x0F, 0x4C, 0x2A, 0x0C, 0x00, 0x33, 0xCC, 0xDE, - 0x86, 0x32, 0x38, 0xB0, 0xEA, 0x17, 0x03, 0x80, 0x8F, 0x8C, 0x18, 0x69, 0x12, 0xFA, 0x8D, 0x03, - 0x4C, 0x6C, 0xBF, 0x07, 0x6E, 0xC4, 0x24, 0xC3, 0xA5, 0xE2, 0x83, 0xFF, 0xFB, 0x92, 0x64, 0x79, - 0x0F, 0x14, 0xF7, 0x35, 0x4C, 0x03, 0x1D, 0xD0, 0x60, 0x2B, 0xA3, 0xC9, 0xC8, 0x04, 0x08, 0x02, - 0x92, 0xA8, 0xD5, 0x32, 0x0E, 0x77, 0x2C, 0x40, 0xC2, 0x0E, 0x67, 0x50, 0x23, 0x15, 0xD8, 0x02, - 0x01, 0x91, 0x11, 0x4A, 0x64, 0x68, 0x1F, 0x07, 0x18, 0x18, 0x13, 0x2B, 0x08, 0x54, 0x84, 0x7D, - 0xA5, 0x06, 0x46, 0xCD, 0x5E, 0x22, 0x75, 0xA1, 0x6B, 0x60, 0x34, 0x44, 0xDF, 0x38, 0x27, 0x59, - 0xE2, 0x52, 0x89, 0xF8, 0xE7, 0x07, 0x03, 0x2E, 0x8E, 0xA8, 0xE7, 0x6A, 0x5E, 0xFA, 0xCC, 0x65, - 0x08, 0x40, 0x61, 0xA9, 0x79, 0xE0, 0xEE, 0x01, 0x02, 0x83, 0xBC, 0x4C, 0x69, 0x3C, 0x29, 0x15, - 0x47, 0x8E, 0x72, 0x21, 0x88, 0xC4, 0xD3, 0x91, 0x23, 0xB3, 0x87, 0x3F, 0x0B, 0x16, 0xAF, 0x73, - 0xEE, 0xD1, 0xE5, 0xB9, 0x8E, 0xD2, 0xD2, 0x7F, 0x3D, 0xAF, 0xBE, 0xAF, 0xCA, 0x7C, 0xD2, 0xEB, - 0x7A, 0x9B, 0x61, 0x9B, 0x89, 0x4E, 0x42, 0x5C, 0x28, 0x19, 0x2A, 0xED, 0xF0, 0x00, 0x03, 0x14, - 0x00, 0x77, 0xF0, 0x4A, 0xC5, 0x7F, 0xB7, 0x96, 0x34, 0x46, 0xCC, 0x88, 0x38, 0xC1, 0xDD, 0x61, - 0x01, 0x89, 0x49, 0x21, 0xE3, 0x06, 0xD4, 0x57, 0xF1, 0x60, 0xA1, 0x40, 0x8D, 0x04, 0x85, 0xA7, - 0x40, 0x62, 0x44, 0x07, 0xF1, 0xC6, 0x6D, 0x96, 0xCA, 0x82, 0x5A, 0x10, 0xFA, 0x55, 0x8E, 0x97, - 0x80, 0xD3, 0x93, 0xC8, 0xC3, 0x60, 0xD4, 0xC2, 0xA1, 0x6C, 0xCB, 0x20, 0x70, 0x2C, 0x0D, 0x19, - 0x73, 0x6D, 0x18, 0xF4, 0x39, 0x18, 0x3E, 0x44, 0x18, 0x00, 0x35, 0x80, 0x80, 0xA3, 0x0F, 0x85, - 0x63, 0x34, 0xC0, 0xA1, 0x08, 0x04, 0x70, 0xF2, 0xC6, 0x4C, 0x1E, 0x81, 0x48, 0xD0, 0x13, 0x6E, - 0xBA, 0x8C, 0x19, 0x10, 0xE2, 0x62, 0x10, 0x20, 0xC4, 0xD0, 0x26, 0x16, 0x60, 0x00, 0x3E, 0x34, - 0x5B, 0x09, 0x37, 0x92, 0x77, 0x4C, 0xD4, 0x46, 0xF4, 0x50, 0x73, 0xA6, 0xEA, 0x75, 0xEC, 0x1E, - 0x0A, 0x98, 0x85, 0x40, 0x9C, 0xB2, 0x99, 0xBC, 0x91, 0x4E, 0xEB, 0x09, 0x50, 0x21, 0x43, 0x4C, - 0x64, 0xEB, 0x38, 0x46, 0x8B, 0xB7, 0x81, 0x84, 0xAB, 0xD9, 0x57, 0x8B, 0xA8, 0xA0, 0x55, 0xAB, - 0x0F, 0x18, 0x4A, 0xA5, 0x02, 0x4A, 0x6F, 0xED, 0x66, 0x17, 0xBA, 0xF5, 0x53, 0x6B, 0x30, 0xA7, - 0xDB, 0x75, 0x32, 0x5D, 0xCE, 0x06, 0x52, 0xCE, 0x16, 0x8C, 0x4A, 0x7D, 0x24, 0xA3, 0xCE, 0xF0, - 0x52, 0xDF, 0x35, 0x9D, 0x4E, 0xF4, 0x00, 0x0C, 0x0C, 0x00, 0x1F, 0xF9, 0x40, 0x49, 0xFF, 0xB6, - 0x55, 0x88, 0x65, 0x45, 0xB8, 0x58, 0xD6, 0xB1, 0x84, 0x45, 0xCC, 0x86, 0x49, 0x88, 0x2C, 0xEB, - 0xA7, 0x41, 0x57, 0x20, 0x04, 0xE8, 0x26, 0x2B, 0x53, 0x83, 0xCE, 0x91, 0x1F, 0x52, 0xFC, 0xA5, - 0x05, 0x0A, 0x27, 0x20, 0x02, 0x79, 0x1A, 0x33, 0x00, 0xC2, 0x73, 0x3F, 0xA4, 0x53, 0x0B, 0xC6, - 0xD3, 0x01, 0xC4, 0xE0, 0x35, 0x6A, 0x61, 0x81, 0x3A, 0x6B, 0x9E, 0x7E, 0x69, 0xFF, 0xFB, 0x92, - 0x64, 0x6F, 0x8F, 0x74, 0xBF, 0x35, 0x4D, 0x03, 0xB9, 0x7C, 0xB0, 0x30, 0xA3, 0xD9, 0x94, 0x1D, - 0x25, 0x92, 0x14, 0x98, 0xCF, 0x30, 0x0E, 0xED, 0xF1, 0x48, 0xB4, 0x99, 0xE6, 0x20, 0x20, 0x15, - 0x48, 0xF0, 0xC2, 0x63, 0x78, 0x8C, 0x6A, 0xF8, 0xE0, 0x09, 0x04, 0x8C, 0x1C, 0x52, 0x0C, 0x45, - 0x0B, 0x0C, 0x19, 0x09, 0xCF, 0x1D, 0x2B, 0x8C, 0x3F, 0x01, 0x04, 0x47, 0x78, 0x44, 0x94, 0x55, - 0x03, 0x4C, 0x16, 0x16, 0x15, 0xD9, 0x80, 0x90, 0x87, 0x7F, 0x39, 0xE6, 0x04, 0xA0, 0x50, 0x34, - 0x81, 0x46, 0x60, 0x32, 0x87, 0xA0, 0x98, 0xD0, 0xC2, 0x94, 0x39, 0x1A, 0xE1, 0x0B, 0x59, 0x14, - 0x08, 0x08, 0x35, 0x47, 0xA1, 0x40, 0xF8, 0x39, 0xA2, 0x29, 0x08, 0xFA, 0x64, 0xCF, 0xDD, 0x9B, - 0x6A, 0x82, 0x8A, 0x06, 0x16, 0x00, 0xFB, 0x95, 0xB8, 0x35, 0x16, 0x1E, 0x10, 0x18, 0xDC, 0x51, - 0xAE, 0x7C, 0xB7, 0x6F, 0x93, 0x8A, 0xB4, 0xEA, 0x7B, 0x7E, 0xB5, 0x23, 0xED, 0x1F, 0xE7, 0x36, - 0xDF, 0xF2, 0x16, 0xDD, 0xE7, 0x0C, 0xAE, 0xDB, 0x96, 0x6E, 0x4B, 0x15, 0xC0, 0x3B, 0x82, 0xEC, - 0xC5, 0x78, 0x3D, 0x77, 0xF4, 0x4C, 0x0F, 0x36, 0xA0, 0x87, 0x82, 0xC8, 0x57, 0x93, 0xE2, 0x42, - 0x3C, 0x43, 0xF4, 0x33, 0xAC, 0xBA, 0x97, 0xAB, 0x72, 0xF2, 0x95, 0x0A, 0x10, 0x7B, 0x3C, 0x49, - 0xB4, 0x11, 0xA3, 0xC6, 0x8B, 0xC3, 0x61, 0x81, 0xA1, 0x84, 0xD4, 0x79, 0x1F, 0xAF, 0xA3, 0x74, - 0x15, 0xE1, 0xE1, 0x8A, 0x16, 0x59, 0x1F, 0x8B, 0x31, 0x43, 0xA2, 0x80, 0x8A, 0x46, 0x53, 0x22, - 0x43, 0x08, 0xA9, 0x83, 0x14, 0x07, 0x63, 0x0D, 0xCE, 0x02, 0xB4, 0x88, 0x88, 0x53, 0x3C, 0x69, - 0x7B, 0x16, 0x67, 0xCC, 0x79, 0x05, 0x4C, 0x01, 0x05, 0xC4, 0x21, 0xA1, 0x8C, 0x26, 0x61, 0x89, - 0x81, 0x00, 0x10, 0xBB, 0x38, 0xC8, 0xFC, 0x30, 0x30, 0x27, 0x31, 0x3D, 0x93, 0x32, 0x04, 0x28, - 0x64, 0x06, 0x07, 0x0A, 0x69, 0x9A, 0x28, 0xAC, 0xE5, 0x88, 0x6A, 0xA6, 0x64, 0x5A, 0x5D, 0x10, - 0x1E, 0x5E, 0xCA, 0xF8, 0xE4, 0x03, 0x1A, 0x46, 0x48, 0xC9, 0xD4, 0x77, 0x8A, 0x92, 0x99, 0x2A, - 0x42, 0x00, 0x9D, 0x4B, 0xA2, 0x4C, 0x56, 0x09, 0x47, 0xA8, 0x5D, 0x59, 0x64, 0xC9, 0xAF, 0x03, - 0x34, 0x61, 0xA7, 0x03, 0xA3, 0xA7, 0x61, 0x94, 0x00, 0x06, 0x02, 0xFF, 0x87, 0x0B, 0x86, 0xC8, - 0x08, 0xAD, 0xD8, 0x79, 0xC8, 0xAF, 0x0C, 0x34, 0x09, 0xD9, 0xCB, 0x3F, 0xFF, 0xFF, 0xFF, 0xF9, - 0x4A, 0xAF, 0xEF, 0xAD, 0x12, 0x8E, 0xC4, 0xA2, 0x71, 0x69, 0x55, 0x5A, 0x2A, 0xA5, 0x19, 0xA1, - 0x6A, 0x95, 0xB9, 0x83, 0x23, 0x6F, 0xA3, 0x65, 0xF1, 0x67, 0x42, 0xA0, 0x99, 0xA0, 0x40, 0x27, - 0xFD, 0xE8, 0x23, 0x33, 0x85, 0x08, 0x0A, 0xC6, 0xAD, 0xD1, 0xF8, 0x9C, 0x5D, 0x1B, 0x14, 0x2E, - 0x84, 0x8E, 0xD1, 0x25, 0xEB, 0xDF, 0x28, 0x35, 0x7B, 0xCE, 0x4D, 0x87, 0x8E, 0x1F, 0x1E, 0xFF, - 0xFB, 0x92, 0x64, 0x61, 0x0F, 0x55, 0x05, 0x33, 0xCC, 0x03, 0x3D, 0xD0, 0x70, 0x2B, 0xA6, 0x89, - 0x31, 0x04, 0x07, 0x2E, 0x92, 0x98, 0xD1, 0x32, 0x0E, 0xF3, 0x26, 0xC0, 0xC1, 0x19, 0xA5, 0xA0, - 0x15, 0x89, 0x39, 0x8E, 0x1D, 0xC7, 0x04, 0x51, 0x70, 0x64, 0x1F, 0x01, 0x13, 0x17, 0x70, 0xE0, - 0x2E, 0x67, 0x5C, 0x3A, 0x30, 0x5F, 0x18, 0x78, 0x83, 0x18, 0x84, 0x1A, 0xAB, 0x79, 0xC8, 0x71, - 0x51, 0x86, 0xC7, 0x86, 0xA6, 0x29, 0x99, 0xD8, 0x48, 0x16, 0x03, 0x18, 0x3D, 0x9A, 0x60, 0xA0, - 0xD8, 0x89, 0xC8, 0x76, 0x86, 0x09, 0x91, 0x01, 0x06, 0x7A, 0x8D, 0x84, 0xFA, 0x44, 0x01, 0xDE, - 0xD4, 0xC1, 0x72, 0x45, 0xE3, 0x69, 0x26, 0x71, 0xCD, 0x48, 0x95, 0x60, 0xE4, 0x9A, 0x21, 0xD7, - 0x63, 0xE8, 0x54, 0xB8, 0x8A, 0x37, 0x1C, 0xCD, 0x2D, 0x67, 0xA6, 0x93, 0x11, 0xE2, 0x8F, 0xE1, - 0x8A, 0x66, 0x51, 0x54, 0xC9, 0x99, 0x85, 0x84, 0x48, 0xE0, 0x47, 0x00, 0x35, 0xAA, 0x1B, 0xB2, - 0x23, 0x52, 0x0D, 0x83, 0x9E, 0xEA, 0x54, 0xC5, 0x2F, 0x3A, 0xF3, 0xF5, 0xD6, 0xE6, 0x10, 0xEF, - 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFC, 0xBE, 0xB4, 0x79, 0x5A, 0x6C, 0x28, 0x7C, 0x1B, 0x2D, - 0x53, 0x86, 0x74, 0x5F, 0x07, 0x42, 0x5B, 0x96, 0x9A, 0x4C, 0xBE, 0xEB, 0x67, 0xA4, 0x2A, 0x88, - 0xC7, 0xF0, 0x03, 0x00, 0x0C, 0x7E, 0x7F, 0x1E, 0x00, 0x90, 0xA4, 0x75, 0xDF, 0xF0, 0xC4, 0x0E, - 0x57, 0xDC, 0x9B, 0xDA, 0x66, 0xF7, 0xFE, 0x4E, 0x31, 0x33, 0x23, 0xAB, 0x9F, 0xF5, 0x17, 0x0E, - 0x2E, 0x41, 0x7F, 0xA1, 0x39, 0xDF, 0xFD, 0x13, 0xEF, 0xC5, 0x87, 0x50, 0x44, 0x3B, 0xE8, 0xC6, - 0x40, 0x55, 0x2A, 0x2E, 0xE9, 0x81, 0x20, 0xE1, 0xB5, 0x10, 0x71, 0x8E, 0x62, 0x81, 0x98, 0x4C, - 0xB1, 0x93, 0x02, 0xD1, 0x30, 0x82, 0x73, 0x84, 0x8E, 0x61, 0x50, 0x4C, 0x30, 0x1B, 0x80, 0x8B, - 0xA5, 0x05, 0x1E, 0x06, 0xCC, 0x15, 0x02, 0x0C, 0x3E, 0x2D, 0x8D, 0x3B, 0x02, 0x4C, 0x01, 0x04, - 0x8C, 0x10, 0x1E, 0x07, 0xE0, 0x00, 0x83, 0x98, 0xA0, 0xAE, 0x00, 0xA8, 0x61, 0x6A, 0xCE, 0x02, - 0x0F, 0xB1, 0xD2, 0xC1, 0x80, 0xE0, 0x75, 0xCC, 0x84, 0xB6, 0xC2, 0x30, 0x70, 0x05, 0xDC, 0x48, - 0x78, 0x19, 0x02, 0x88, 0xB1, 0xB6, 0x52, 0xF7, 0x27, 0x2D, 0xC8, 0xE3, 0x4F, 0x93, 0x54, 0xCA, - 0x96, 0x07, 0x1E, 0x0A, 0x11, 0x9E, 0x40, 0x95, 0x20, 0x0F, 0xA8, 0x50, 0x80, 0xE6, 0xC6, 0x24, - 0xC3, 0x5A, 0x79, 0x6A, 0x35, 0x09, 0x13, 0x1B, 0x69, 0xB1, 0x88, 0x57, 0xFF, 0xFF, 0xE1, 0xCC, - 0x30, 0xB9, 0x49, 0x63, 0x58, 0x65, 0xB8, 0xF4, 0x7F, 0xD5, 0x55, 0x56, 0x44, 0x89, 0x8C, 0xAE, - 0x82, 0x1C, 0x8F, 0xB7, 0xFE, 0xB4, 0x6A, 0xFD, 0x49, 0x4D, 0xC6, 0x94, 0xC1, 0xE0, 0x4E, 0x80, - 0x28, 0x00, 0x00, 0x00, 0x12, 0x00, 0x6B, 0xF7, 0xF0, 0xB0, 0x5C, 0x52, 0x13, 0x3F, 0xD9, 0xA2, - 0x7B, 0xFF, 0xFB, 0x92, 0x64, 0x57, 0x0F, 0x04, 0xE1, 0x34, 0xCC, 0x03, 0xBA, 0xC3, 0xB0, 0x31, - 0xE5, 0xB9, 0xBC, 0x1C, 0xC2, 0x74, 0x52, 0x48, 0xD1, 0x2E, 0x0E, 0xEF, 0x46, 0x88, 0xBD, 0x97, - 0xA5, 0xE0, 0xA4, 0x09, 0xE8, 0x95, 0x47, 0x91, 0x30, 0x0C, 0x57, 0xE8, 0x47, 0x10, 0xDD, 0x42, - 0x89, 0x30, 0x93, 0x1C, 0x58, 0xAF, 0xEA, 0x74, 0x3A, 0x7F, 0xB2, 0xB7, 0xD5, 0x31, 0x85, 0x89, - 0x84, 0x5B, 0x8D, 0x12, 0x0C, 0x69, 0x60, 0x92, 0x04, 0xE7, 0x57, 0xB4, 0xCE, 0x65, 0x84, 0xC2, - 0xD7, 0x20, 0x0D, 0xAE, 0x18, 0x84, 0x3F, 0x9A, 0x62, 0x85, 0x1C, 0x2A, 0xA1, 0x84, 0xAC, 0x9A, - 0x00, 0xB9, 0x10, 0x71, 0x8A, 0x9E, 0x18, 0x69, 0xD1, 0xA6, 0xCD, 0x1E, 0x9C, 0xCA, 0x6E, 0x68, - 0xD4, 0x26, 0x9A, 0xFE, 0x28, 0x12, 0xC0, 0x9A, 0xF8, 0x70, 0xE8, 0x91, 0x75, 0x6E, 0x97, 0xB8, - 0x1C, 0xF8, 0x94, 0x10, 0xE9, 0x61, 0x62, 0x46, 0x2C, 0xF9, 0xD5, 0xF0, 0x5A, 0xD8, 0x8A, 0x5B, - 0x39, 0x80, 0xA1, 0xAE, 0x53, 0x72, 0x82, 0xEB, 0xC0, 0xF2, 0x6E, 0xFD, 0xF5, 0x8E, 0xE3, 0x29, - 0xE5, 0x2D, 0x6E, 0x2B, 0x15, 0xFC, 0x42, 0x48, 0xE0, 0x94, 0x45, 0xA5, 0x7A, 0x5A, 0x7C, 0xAA, - 0x8A, 0x19, 0x75, 0xE6, 0xEF, 0x6F, 0xFF, 0xFE, 0xB5, 0xEC, 0xE2, 0x12, 0xA9, 0xFB, 0x7A, 0xA7, - 0xE6, 0xEA, 0xC8, 0x33, 0xAF, 0x4B, 0x05, 0xAF, 0x96, 0x4C, 0xBC, 0x58, 0xD4, 0xBB, 0x1D, 0x55, - 0xFB, 0x96, 0x29, 0xA9, 0x9D, 0xB9, 0xC5, 0xC0, 0x10, 0xC0, 0x02, 0x08, 0xDB, 0xFB, 0x28, 0xAC, - 0x02, 0xC1, 0x5C, 0x20, 0x5E, 0x15, 0x20, 0x4F, 0xA9, 0x28, 0x39, 0xEC, 0x2C, 0x47, 0x5F, 0xF0, - 0xD2, 0xB1, 0x5A, 0x7B, 0x32, 0xAD, 0x0D, 0x11, 0x86, 0xDA, 0xBA, 0x97, 0xFE, 0x87, 0xF6, 0xDF, - 0x70, 0x83, 0x97, 0x40, 0x39, 0x2C, 0xCD, 0x6F, 0xCC, 0x18, 0x28, 0xCE, 0xE2, 0x67, 0x0C, 0x9C, - 0x27, 0x0D, 0x9B, 0x42, 0x3C, 0x72, 0x24, 0x10, 0x8D, 0x38, 0x04, 0x78, 0xE1, 0x65, 0x43, 0x25, - 0x93, 0x12, 0x64, 0xC3, 0x41, 0xD3, 0x47, 0x0D, 0x4C, 0x74, 0x44, 0x22, 0x4A, 0x19, 0x59, 0xA0, - 0xE4, 0x00, 0x83, 0x23, 0xC0, 0xD9, 0x4B, 0x66, 0xA0, 0x43, 0x95, 0x26, 0x8B, 0xD0, 0xF9, 0xB2, - 0x14, 0x10, 0x88, 0x45, 0x17, 0xC8, 0x98, 0x11, 0x94, 0x92, 0x6E, 0xA1, 0x99, 0x20, 0xE1, 0x40, - 0xE8, 0x3C, 0xD6, 0x10, 0x1E, 0x8F, 0x6E, 0x64, 0x4A, 0x38, 0xD8, 0x60, 0x19, 0x46, 0x32, 0x94, - 0x84, 0x64, 0x6A, 0xA3, 0x1E, 0x87, 0x1E, 0x78, 0x10, 0x68, 0x4A, 0x80, 0x37, 0xED, 0x6D, 0x4E, - 0xD8, 0x15, 0x35, 0x2C, 0x41, 0xDE, 0x86, 0xB2, 0xCB, 0xFF, 0x5F, 0x95, 0x9A, 0xB5, 0xA7, 0xAC, - 0xE1, 0xF6, 0x39, 0xFC, 0xD6, 0x71, 0x45, 0x3F, 0x1D, 0xB1, 0x48, 0xA3, 0xCE, 0xF5, 0x17, 0xFE, - 0x5F, 0xAE, 0x6E, 0x2B, 0x29, 0x9A, 0xB6, 0x40, 0x00, 0x00, 0x08, 0x00, 0x08, 0x37, 0x48, 0xCB, - 0x10, 0x47, 0x50, 0xFF, 0xFB, 0x92, 0x64, 0x4E, 0x0F, 0xC4, 0x7F, 0x34, 0xCA, 0x83, 0xBC, 0xD0, - 0xC0, 0x31, 0xC5, 0x79, 0x77, 0x08, 0xC7, 0x2E, 0x13, 0x90, 0xD1, 0x22, 0x0F, 0x6F, 0x28, 0x88, - 0xB7, 0x8B, 0xA6, 0x04, 0x76, 0x0D, 0x0A, 0x0C, 0xAF, 0xF4, 0xA4, 0xF9, 0xDB, 0x06, 0x29, 0xE0, - 0x08, 0x46, 0x8F, 0x04, 0x05, 0xB3, 0xFD, 0x48, 0xEE, 0xC8, 0x34, 0x61, 0xC1, 0x22, 0x38, 0x4D, - 0x48, 0x4F, 0xCF, 0xED, 0xFE, 0x9E, 0x8B, 0xF2, 0xAC, 0x8B, 0x9E, 0xF0, 0xF8, 0x5C, 0x18, 0x46, - 0x81, 0x18, 0xD2, 0x6C, 0xAB, 0x4C, 0x12, 0x88, 0x88, 0xC2, 0x1C, 0x3A, 0x0C, 0x80, 0x81, 0x1C, - 0xC0, 0x90, 0x02, 0xCC, 0x1E, 0xC9, 0x64, 0xC3, 0x74, 0x0F, 0x0C, 0x55, 0x82, 0x64, 0xE0, 0x44, - 0x0C, 0x84, 0x60, 0xC0, 0xED, 0x0F, 0x24, 0x18, 0x42, 0xDC, 0x6C, 0x03, 0x46, 0x02, 0x40, 0x61, - 0x43, 0xA4, 0xD9, 0x36, 0xCB, 0x38, 0x80, 0x50, 0x81, 0xD0, 0x79, 0x4B, 0x57, 0x60, 0x88, 0xB4, - 0x7E, 0x02, 0x8C, 0x8D, 0xC2, 0x82, 0x21, 0xD0, 0xBA, 0x40, 0x81, 0xD9, 0x99, 0x6A, 0x52, 0x4C, - 0xA8, 0x79, 0x92, 0x29, 0x58, 0xF2, 0x14, 0x6F, 0x2F, 0xCC, 0x3A, 0xA1, 0xA8, 0x91, 0x2D, 0x56, - 0x40, 0x85, 0x41, 0x14, 0x22, 0x22, 0xA8, 0x83, 0x8D, 0x31, 0x02, 0x71, 0x46, 0xB4, 0x08, 0x39, - 0x81, 0x26, 0x69, 0x7D, 0x01, 0x4D, 0xC8, 0xE9, 0xE5, 0x11, 0x3A, 0x5D, 0x7F, 0xFF, 0xE5, 0x57, - 0x98, 0xFD, 0x2E, 0xB9, 0xF3, 0xDD, 0xFD, 0x6F, 0x8F, 0xB4, 0x5A, 0xED, 0x2C, 0x7A, 0x1A, 0x97, - 0x63, 0xAF, 0xCF, 0xFF, 0x95, 0x65, 0x32, 0x9B, 0x32, 0x85, 0x00, 0xE4, 0x59, 0xD4, 0x64, 0x3A, - 0x16, 0x3C, 0x7C, 0x94, 0x07, 0x13, 0x9E, 0x30, 0x86, 0x3C, 0x10, 0x13, 0xAB, 0x19, 0x54, 0x70, - 0xAA, 0x68, 0x47, 0xFE, 0x94, 0x82, 0x82, 0x43, 0x4E, 0x91, 0x05, 0xAF, 0x39, 0x11, 0x78, 0xF0, - 0xD0, 0xE7, 0xE4, 0xA1, 0xE0, 0x0F, 0x91, 0x14, 0x08, 0x8C, 0x48, 0x46, 0xCF, 0x79, 0x64, 0x0D, - 0x55, 0x5E, 0x4C, 0xE8, 0x0D, 0xCC, 0xEA, 0x4E, 0x0D, 0x26, 0x3A, 0x8E, 0x0A, 0x52, 0x0C, 0xA7, - 0x3A, 0x4C, 0xA4, 0x2A, 0x04, 0x40, 0x79, 0x82, 0x82, 0x59, 0x8E, 0xC3, 0xD9, 0x8E, 0x03, 0x01, - 0x82, 0xC1, 0x79, 0x87, 0x22, 0x29, 0x73, 0x8C, 0x19, 0x04, 0x47, 0xD2, 0x66, 0xEB, 0x06, 0xD3, - 0x4C, 0x11, 0x40, 0x87, 0x26, 0xC2, 0xCA, 0x50, 0xA5, 0xD8, 0xAE, 0x0A, 0x03, 0x2E, 0x9A, 0x00, - 0x49, 0x44, 0x03, 0x04, 0x0C, 0x10, 0x89, 0x25, 0x3E, 0x03, 0x41, 0x33, 0x54, 0x61, 0xDF, 0x11, - 0x06, 0x44, 0x73, 0xAC, 0xB9, 0x50, 0x86, 0xE3, 0x9C, 0x25, 0x30, 0x20, 0x62, 0x55, 0x09, 0x06, - 0x20, 0x11, 0x3E, 0x41, 0xA4, 0x21, 0x02, 0xBC, 0x8A, 0x87, 0x44, 0x1C, 0x68, 0x5C, 0x47, 0xB9, - 0xFD, 0x65, 0xAF, 0x24, 0x1F, 0xFF, 0xF6, 0x95, 0xF2, 0xB8, 0xD6, 0xFF, 0xC6, 0x06, 0x44, 0xEE, - 0x06, 0x0C, 0x1D, 0xE8, 0x2A, 0xFF, 0xFB, 0x92, 0x64, 0x47, 0x0E, 0x84, 0xBB, 0x34, 0xC8, 0x03, - 0xB9, 0x43, 0xE0, 0x2E, 0x83, 0xF9, 0x73, 0x09, 0x23, 0x26, 0x14, 0x00, 0xD3, 0x22, 0x6E, 0xE5, - 0x4F, 0x80, 0xB7, 0x8F, 0xA6, 0x68, 0x04, 0x8C, 0x68, 0xBB, 0x96, 0x19, 0x04, 0xCF, 0xAA, 0x4C, - 0xAB, 0xFD, 0x00, 0x00, 0x4C, 0x00, 0x04, 0x13, 0xE2, 0x44, 0x72, 0x5B, 0x8F, 0xA0, 0x0F, 0x03, - 0x87, 0xC2, 0x85, 0x43, 0x9F, 0x9C, 0x4D, 0x37, 0x28, 0x8D, 0x42, 0x49, 0x21, 0x57, 0x43, 0x64, - 0x4A, 0xEB, 0x87, 0x03, 0x7F, 0x07, 0x06, 0x34, 0xEC, 0xA3, 0xB5, 0x7D, 0x87, 0x95, 0xAF, 0x52, - 0x54, 0x01, 0x90, 0x04, 0x10, 0x18, 0x04, 0xB9, 0x1F, 0x1C, 0x5A, 0x05, 0xA2, 0xD3, 0x0B, 0x04, - 0xB3, 0x28, 0x87, 0x73, 0x30, 0x90, 0x23, 0x47, 0xDB, 0xA3, 0x2A, 0x98, 0x03, 0x03, 0x97, 0xD0, - 0x70, 0xF4, 0x0E, 0x1F, 0xCC, 0xB3, 0x2D, 0x0C, 0x9E, 0x16, 0x8C, 0x8E, 0x0B, 0x4C, 0x53, 0x24, - 0x0C, 0x0E, 0x0E, 0x92, 0xED, 0x8D, 0x57, 0x7F, 0x88, 0x82, 0x4D, 0x57, 0x61, 0x2C, 0x62, 0x4C, - 0xF5, 0xA1, 0xA3, 0x3C, 0x18, 0xD2, 0x4B, 0x2A, 0xA6, 0xCA, 0x06, 0x02, 0x44, 0x47, 0x48, 0x30, - 0x03, 0x1E, 0x60, 0x75, 0xA6, 0x41, 0x43, 0x44, 0x29, 0x84, 0x2D, 0x23, 0x62, 0xF9, 0x4B, 0x8A, - 0x82, 0x82, 0x0F, 0x52, 0x22, 0xD8, 0x0F, 0xAB, 0x00, 0xCD, 0x16, 0x2B, 0x54, 0xAC, 0x61, 0x10, - 0x57, 0xB1, 0x9A, 0xAA, 0x0A, 0xAA, 0xF1, 0x90, 0xD4, 0xD9, 0x6C, 0x31, 0x6F, 0xEF, 0x2F, 0xFB, - 0x19, 0x6C, 0xF2, 0x80, 0xDE, 0x3E, 0x71, 0x58, 0x10, 0x68, 0xC4, 0x00, 0x51, 0x2F, 0x11, 0xC2, - 0xD9, 0x20, 0x2E, 0x13, 0x5D, 0x6F, 0xBD, 0xAB, 0xF7, 0x0E, 0xEB, 0xFF, 0xFF, 0xF3, 0x5A, 0xB6, - 0x50, 0x60, 0x00, 0x02, 0x26, 0x81, 0xE9, 0x13, 0x5B, 0xEA, 0x40, 0x70, 0xB2, 0x33, 0x1E, 0x59, - 0xEF, 0xA7, 0x5C, 0xE4, 0x8E, 0x09, 0xC4, 0xB6, 0xC3, 0x9B, 0xFF, 0xB7, 0xB1, 0xA8, 0x9B, 0x01, - 0x48, 0x1C, 0x51, 0x0A, 0x63, 0x69, 0x46, 0x43, 0xB7, 0xB7, 0xD7, 0xFF, 0x4E, 0xDE, 0x51, 0x01, - 0x04, 0x00, 0x11, 0x81, 0xEA, 0xA1, 0xDF, 0x2B, 0xC9, 0x90, 0x46, 0xC8, 0x43, 0x7E, 0x60, 0xEA, - 0x9E, 0x6B, 0x91, 0x46, 0x6B, 0xAD, 0x32, 0x60, 0x92, 0x94, 0x63, 0x21, 0x04, 0x63, 0x88, 0x58, - 0x63, 0xA0, 0x78, 0x61, 0x70, 0xDC, 0x04, 0x06, 0xCC, 0xA5, 0x15, 0x4C, 0x7C, 0x12, 0x4B, 0x98, - 0x10, 0x01, 0x07, 0x81, 0x40, 0x03, 0x12, 0xB7, 0xD7, 0xB3, 0x05, 0x2F, 0x83, 0xCA, 0xE1, 0x2B, - 0xD5, 0xEA, 0xBF, 0x12, 0x55, 0x64, 0xA7, 0x1B, 0xA2, 0xD4, 0x92, 0x14, 0xC4, 0x45, 0x14, 0x11, - 0x90, 0x08, 0x44, 0xB0, 0x49, 0x67, 0xF5, 0xA5, 0x3E, 0x78, 0xCC, 0x21, 0x34, 0x12, 0x73, 0x2E, - 0xD3, 0xFC, 0x85, 0x2B, 0x10, 0xB9, 0x62, 0xC4, 0x03, 0x44, 0xB3, 0x2C, 0xE5, 0x45, 0xC6, 0xF6, - 0x79, 0xD0, 0xD5, 0xDC, 0x52, 0x62, 0x28, 0xFF, 0xFB, 0x92, 0x64, 0x3C, 0x0F, 0x64, 0xC3, 0x33, - 0xC9, 0x0B, 0xB8, 0x63, 0xE0, 0x2F, 0x03, 0xD9, 0x69, 0x04, 0x08, 0x06, 0x13, 0x40, 0xD3, 0x26, - 0x0E, 0xEF, 0x07, 0x00, 0xB6, 0x0C, 0xA6, 0x68, 0x20, 0x0C, 0x88, 0xA7, 0xBA, 0x68, 0x35, 0x5E, - 0xDE, 0x3B, 0x3D, 0x33, 0x7B, 0xB6, 0xEC, 0xD3, 0x7E, 0x81, 0xC2, 0x77, 0x1F, 0xB1, 0x93, 0xC4, - 0x8A, 0xA6, 0x40, 0x9E, 0x39, 0x29, 0x1C, 0x16, 0x83, 0xFF, 0xFD, 0x60, 0x04, 0x00, 0x00, 0x03, - 0x82, 0xF4, 0x73, 0x83, 0xA3, 0xBE, 0x14, 0xB3, 0xC6, 0x25, 0x5D, 0x4F, 0x05, 0x30, 0x95, 0xE9, - 0x43, 0xC2, 0xCF, 0x48, 0xF5, 0xFD, 0x50, 0xC9, 0xBA, 0x41, 0xDC, 0x5B, 0x0C, 0x50, 0xB1, 0xB7, - 0x20, 0x40, 0xBA, 0xBE, 0x2C, 0x27, 0x6D, 0x15, 0x7F, 0xFD, 0x6B, 0xC8, 0xC1, 0xF2, 0x28, 0xE5, - 0xC5, 0x70, 0xC4, 0xA6, 0x78, 0xD0, 0xD1, 0x28, 0xC7, 0xE3, 0x94, 0xC0, 0xD1, 0x34, 0xCB, 0xC5, - 0xA4, 0xCA, 0xCF, 0x4D, 0x27, 0x58, 0x5B, 0x74, 0x86, 0x20, 0xCD, 0x89, 0x45, 0xAA, 0x8D, 0xCD, - 0x24, 0xD7, 0x92, 0x03, 0x00, 0x41, 0xA1, 0x04, 0x48, 0x20, 0x41, 0x22, 0xFF, 0x0A, 0x80, 0x16, - 0x70, 0xB3, 0x8B, 0x76, 0xBC, 0xAE, 0x6E, 0x59, 0x28, 0x25, 0x6B, 0x7C, 0xE8, 0x33, 0xE4, 0x74, - 0x4E, 0x16, 0x94, 0x3C, 0x30, 0x33, 0x0B, 0xD6, 0xEA, 0x80, 0x8E, 0xF9, 0xFF, 0x25, 0x15, 0xB2, - 0x42, 0xD0, 0x1F, 0x8C, 0x0E, 0x3F, 0xBC, 0xC2, 0x14, 0x56, 0x47, 0xC2, 0x66, 0xDF, 0x6B, 0x02, - 0x15, 0x80, 0x4A, 0xCD, 0x91, 0x29, 0x42, 0xD5, 0xCA, 0x9D, 0x2D, 0x47, 0x6A, 0x8E, 0xED, 0x3C, - 0xBB, 0x1D, 0x43, 0xF1, 0x7C, 0x31, 0x97, 0xDE, 0xF7, 0xF2, 0x07, 0x92, 0x3F, 0x33, 0xD5, 0xDD, - 0xA7, 0xF2, 0x2D, 0x2F, 0x5D, 0x12, 0x06, 0x72, 0xB0, 0xFB, 0x59, 0x0F, 0x26, 0x52, 0xC8, 0xDC, - 0x27, 0x92, 0xB9, 0xFB, 0xE2, 0x84, 0x05, 0x00, 0x1B, 0x54, 0xFE, 0xBC, 0x10, 0x5E, 0x0D, 0x6B, - 0x06, 0x55, 0xFF, 0x56, 0x83, 0xA6, 0x15, 0xCD, 0xD0, 0x61, 0x3F, 0xF7, 0xA2, 0x14, 0x40, 0x4C, - 0x78, 0x12, 0x26, 0x0F, 0x02, 0xF9, 0xF4, 0x49, 0x67, 0x13, 0x78, 0x40, 0xB9, 0xEE, 0x77, 0xFF, - 0x14, 0xDA, 0x00, 0x03, 0x04, 0x0F, 0x30, 0x31, 0x83, 0xFD, 0x93, 0x37, 0x1C, 0xC3, 0x1F, 0x19, - 0x37, 0xEA, 0x33, 0x1E, 0x3A, 0x05, 0x54, 0x1F, 0xED, 0xF2, 0x3C, 0x4D, 0x08, 0x3C, 0x81, 0x52, - 0x46, 0x56, 0x0B, 0x03, 0x8B, 0x06, 0x54, 0x33, 0x1F, 0x99, 0x9E, 0x3F, 0x87, 0xE4, 0x65, 0x1E, - 0x3C, 0x39, 0xB4, 0xF0, 0xA8, 0xA1, 0x7B, 0xC4, 0x96, 0x45, 0x04, 0xAC, 0x79, 0xEF, 0xB8, 0x09, - 0xBE, 0xAF, 0xE1, 0xB3, 0x10, 0x23, 0x08, 0xA4, 0x0C, 0x44, 0x00, 0xB3, 0xC6, 0xA0, 0xC5, 0xC3, - 0x14, 0x08, 0x60, 0xC4, 0x7D, 0x2C, 0x9A, 0xCF, 0xE4, 0x91, 0x6C, 0xB4, 0xC5, 0x1B, 0x11, 0x66, - 0x5A, 0xA0, 0x50, 0xEE, 0x70, 0x5C, 0x74, 0x85, 0x33, 0xFF, 0xFB, 0x92, 0x64, 0x33, 0x8E, 0x45, - 0x50, 0x34, 0x4A, 0x93, 0x7C, 0xC9, 0xA0, 0x2F, 0x08, 0x3A, 0x0A, 0x08, 0x22, 0x7E, 0x94, 0x20, - 0xCB, 0x2E, 0x6E, 0x63, 0x51, 0x00, 0xB1, 0x8E, 0xE8, 0x0C, 0x30, 0x0C, 0xC2, 0xC7, 0x1C, 0x58, - 0xE6, 0xB0, 0xC8, 0x49, 0x03, 0x06, 0xA3, 0x7F, 0x4B, 0x78, 0x92, 0x89, 0x98, 0xE5, 0x59, 0xFD, - 0xC0, 0x0C, 0xDB, 0xF7, 0x00, 0x3A, 0xD7, 0xA0, 0xB6, 0x5B, 0x2A, 0x96, 0x43, 0xD2, 0xA7, 0xEB, - 0xE1, 0xFB, 0x2E, 0x0B, 0xB3, 0x28, 0x92, 0xB8, 0xCD, 0x25, 0x41, 0x53, 0x9C, 0x1C, 0x34, 0x1E, - 0x80, 0xB7, 0xBA, 0xED, 0xA9, 0x76, 0x15, 0x6E, 0x3F, 0xF2, 0xE4, 0xEB, 0xAD, 0x8E, 0xB5, 0xAB, - 0x40, 0x30, 0x04, 0x00, 0x08, 0x74, 0x02, 0x35, 0x1B, 0xF5, 0x41, 0xC3, 0x83, 0x39, 0xAB, 0x7F, - 0x3A, 0x30, 0x03, 0x8C, 0xCA, 0x40, 0xF9, 0xE6, 0x40, 0x71, 0xC6, 0xD9, 0x8E, 0xBE, 0x7F, 0xDF, - 0xFF, 0xEB, 0xF5, 0x5D, 0x7F, 0xFF, 0x9D, 0x4B, 0xA3, 0xF0, 0x31, 0x84, 0x35, 0x05, 0xAC, 0x06, - 0x00, 0x02, 0x0A, 0x18, 0x34, 0x1A, 0x6B, 0x81, 0x11, 0x99, 0xD3, 0x66, 0x1C, 0x02, 0x19, 0x1C, - 0x12, 0x61, 0x80, 0x71, 0xCF, 0xE7, 0x66, 0x20, 0x1E, 0x14, 0x37, 0x03, 0x0C, 0x86, 0x11, 0x15, - 0x05, 0x44, 0xA1, 0x8E, 0x23, 0x34, 0xA6, 0xCC, 0xB0, 0x43, 0x33, 0x18, 0xC8, 0xD3, 0xCD, 0x40, - 0xB8, 0x80, 0xCB, 0xA3, 0x43, 0x10, 0x09, 0xCC, 0x88, 0x1A, 0x32, 0x08, 0xCB, 0xE0, 0xD9, 0x1C, - 0x8E, 0xDB, 0x30, 0xF7, 0x5E, 0x52, 0x08, 0x80, 0x86, 0x41, 0x5F, 0x03, 0x08, 0x34, 0xC0, 0x2B, - 0x4F, 0xFA, 0x3E, 0x10, 0xCC, 0xD2, 0xF7, 0x99, 0x2A, 0x6A, 0x3B, 0x73, 0x56, 0xAB, 0x17, 0x27, - 0xB9, 0x2F, 0x2F, 0x01, 0x23, 0x1C, 0x94, 0x88, 0x2E, 0xE2, 0x98, 0xAB, 0x61, 0xC5, 0x18, 0x35, - 0x08, 0x64, 0x08, 0x41, 0x17, 0x51, 0xE0, 0x56, 0xD8, 0xF2, 0xBD, 0x97, 0xDA, 0xA9, 0xBB, 0x57, - 0x37, 0x67, 0x3A, 0x5A, 0x7A, 0xF2, 0xFC, 0xBB, 0xAA, 0xF4, 0xFD, 0xAB, 0x2B, 0xEF, 0x27, 0x35, - 0x5F, 0xB1, 0xF2, 0xC0, 0x36, 0xA5, 0x54, 0x80, 0x3B, 0x53, 0xDE, 0x74, 0xFF, 0xFB, 0x62, 0xCF, - 0x00, 0x06, 0x14, 0x00, 0x91, 0x21, 0x84, 0x4F, 0x81, 0x07, 0x4C, 0x18, 0xA0, 0x60, 0x62, 0x77, - 0xA6, 0x18, 0x90, 0x90, 0x90, 0xCD, 0x62, 0x35, 0x0E, 0xA6, 0xF3, 0xFE, 0xA3, 0xA0, 0x94, 0xBA, - 0x10, 0x20, 0x4C, 0x26, 0x5F, 0xF4, 0xFF, 0x0D, 0x96, 0xDF, 0xFE, 0xBD, 0x35, 0x30, 0x38, 0x64, - 0xC1, 0x23, 0x91, 0xA7, 0x91, 0x87, 0x86, 0xA1, 0x93, 0x63, 0x08, 0x02, 0xCC, 0x98, 0x39, 0x33, - 0x88, 0x1C, 0xE3, 0xC5, 0xF3, 0x1B, 0x04, 0x80, 0x48, 0x43, 0x0A, 0x05, 0x4C, 0x74, 0x38, 0x31, - 0x10, 0xAC, 0xC1, 0xE0, 0x13, 0x3D, 0x9F, 0x0D, 0x06, 0x20, 0x02, 0x0C, 0xC0, 0xB0, 0x99, 0x8A, - 0x99, 0xC1, 0xA4, 0x58, 0x73, 0x28, 0xEB, 0x09, 0x24, 0x02, 0x44, 0xFF, 0xFB, 0x92, 0x64, 0x1F, - 0x0F, 0x44, 0xB7, 0x33, 0x4C, 0x83, 0x99, 0x7B, 0xE0, 0x30, 0x83, 0xF9, 0xDD, 0x08, 0x43, 0x0A, - 0x11, 0x58, 0xCD, 0x32, 0x0D, 0xE9, 0xE9, 0x00, 0xBA, 0x13, 0xE6, 0x50, 0x83, 0x09, 0xBA, 0x84, - 0x87, 0xD3, 0x34, 0x53, 0x28, 0x04, 0xB9, 0x2B, 0x25, 0x38, 0x19, 0xC8, 0x28, 0xE5, 0xE4, 0x97, - 0x48, 0xF4, 0x84, 0x4E, 0x2A, 0x2F, 0x42, 0xE7, 0xAC, 0xDF, 0xDD, 0x56, 0xD8, 0xB4, 0xEB, 0x44, - 0x89, 0x12, 0x10, 0x1D, 0xA5, 0xAA, 0x8F, 0x22, 0x40, 0x2E, 0xD4, 0x35, 0x51, 0x0C, 0x10, 0x4C, - 0xCC, 0xD2, 0x01, 0xF4, 0x74, 0x18, 0x0E, 0x8B, 0x2E, 0x91, 0x89, 0x35, 0xC3, 0x81, 0x91, 0x05, - 0xCB, 0x77, 0xC2, 0x1A, 0x83, 0xC4, 0x39, 0x97, 0x91, 0x08, 0xD3, 0xAD, 0xE2, 0xB5, 0x2E, 0x72, - 0x8F, 0xE4, 0x61, 0x29, 0x36, 0xFE, 0x18, 0x34, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x78, 0x02, - 0x18, 0x06, 0x02, 0x38, 0xDA, 0x50, 0x43, 0xD9, 0x84, 0x90, 0x5C, 0x13, 0xB0, 0x51, 0x2F, 0xA9, - 0x35, 0xAC, 0x21, 0x95, 0xE0, 0x48, 0xF1, 0x45, 0x56, 0xCA, 0xE8, 0x2D, 0x95, 0x07, 0x58, 0xC6, - 0x24, 0xC0, 0x42, 0x2F, 0x9F, 0xFE, 0xC2, 0xB2, 0xC6, 0x04, 0x4E, 0x5A, 0x71, 0x28, 0x43, 0x33, - 0x4E, 0x30, 0x43, 0xA4, 0x20, 0x33, 0x16, 0xD0, 0x14, 0x49, 0xC9, 0xEA, 0x18, 0xC1, 0x58, 0x2A, - 0xC9, 0x98, 0x38, 0x71, 0xD6, 0x19, 0xC0, 0xA6, 0x50, 0xB8, 0xEA, 0x22, 0x02, 0x46, 0x08, 0x1A, - 0x68, 0x35, 0x61, 0x08, 0xB4, 0x26, 0xB9, 0xEE, 0x52, 0x53, 0x8F, 0x07, 0x80, 0x22, 0x42, 0x33, - 0x0D, 0xD8, 0xDA, 0x24, 0xE4, 0x64, 0x95, 0x80, 0xEC, 0x06, 0x62, 0x28, 0x44, 0x8B, 0x98, 0xC6, - 0x57, 0x21, 0xF1, 0x47, 0x66, 0xCD, 0x59, 0x17, 0x28, 0x60, 0x12, 0x64, 0x31, 0x2C, 0x0A, 0x30, - 0x85, 0x00, 0x5A, 0x15, 0x44, 0x19, 0x08, 0x5F, 0x57, 0xAF, 0x9C, 0x83, 0xE8, 0x5B, 0x03, 0x7C, - 0x76, 0xAE, 0xDB, 0xA2, 0x3F, 0x71, 0x24, 0xAC, 0xC4, 0xC1, 0x3A, 0xF5, 0x93, 0x35, 0xC9, 0xDC, - 0x79, 0x74, 0xC2, 0x41, 0x14, 0x76, 0x27, 0x56, 0xD7, 0x65, 0xD1, 0x6B, 0x2B, 0xA3, 0x85, 0xB9, - 0xCB, 0xF6, 0x7D, 0x00, 0x02, 0x1B, 0x34, 0x02, 0xEB, 0x37, 0xE3, 0x0E, 0x17, 0xF9, 0x45, 0x4B, - 0xE5, 0x1C, 0xA3, 0xDF, 0xFD, 0xF8, 0xAB, 0x11, 0x90, 0xE6, 0xE2, 0x3B, 0xBC, 0x95, 0x1E, 0xEC, - 0x83, 0x69, 0xD5, 0x09, 0x97, 0x66, 0x5A, 0xFD, 0x6E, 0x94, 0xB7, 0xFE, 0xF8, 0x2F, 0x0F, 0xCA, - 0x38, 0x82, 0x00, 0x00, 0x05, 0x02, 0x04, 0x04, 0x9E, 0x8C, 0x01, 0x03, 0x34, 0xB9, 0x48, 0xC6, - 0xED, 0x93, 0x11, 0x93, 0x8C, 0xE4, 0xD9, 0x30, 0xBA, 0x10, 0xCA, 0x82, 0x73, 0x65, 0x8B, 0x43, - 0x02, 0x00, 0xE2, 0x41, 0x74, 0x4C, 0x4A, 0x35, 0x4C, 0x60, 0x35, 0xF0, 0x88, 0x02, 0x40, 0x03, - 0x0E, 0xFD, 0x23, 0x17, 0x65, 0xEA, 0xC0, 0xCB, 0x18, 0x92, 0x98, 0xC9, 0xD0, 0xFF, 0xFB, 0x92, - 0x64, 0x1D, 0x8E, 0x04, 0x9B, 0x33, 0x4C, 0x1B, 0x98, 0x63, 0xE0, 0x32, 0x43, 0x49, 0xDF, 0x00, - 0xC3, 0x18, 0x13, 0xC4, 0xCD, 0x28, 0x4F, 0x73, 0x05, 0x00, 0xBE, 0x21, 0x27, 0xF4, 0x11, 0x0F, - 0x5A, 0xE2, 0x91, 0x70, 0xFA, 0x64, 0xAF, 0xC8, 0x69, 0xEC, 0x5B, 0xC9, 0x52, 0x4C, 0x55, 0xD8, - 0xA1, 0x6C, 0xFD, 0xD4, 0xB9, 0x0B, 0xA2, 0x81, 0x21, 0xE8, 0x7E, 0x96, 0x2A, 0xA5, 0xB6, 0x93, - 0xAA, 0xBC, 0xCA, 0x02, 0x8B, 0x70, 0xA8, 0xC2, 0x88, 0x53, 0x77, 0xAC, 0x80, 0x93, 0xD0, 0xD3, - 0xCA, 0xF0, 0xC5, 0x9F, 0xE0, 0xB4, 0x08, 0xD4, 0x69, 0x26, 0xB0, 0x4F, 0x3D, 0x25, 0x09, 0x63, - 0xEE, 0xF6, 0x17, 0x6D, 0x25, 0x72, 0x01, 0xD1, 0xEA, 0x19, 0x24, 0x8A, 0xF2, 0xA7, 0x03, 0x2E, - 0xFA, 0xCC, 0x9A, 0xDF, 0xFF, 0x7F, 0x20, 0xED, 0x73, 0x00, 0x08, 0xA0, 0x12, 0x00, 0x00, 0x00, - 0x00, 0x1E, 0x04, 0xE5, 0x6F, 0xEC, 0x88, 0xA5, 0xE7, 0xB8, 0xA8, 0x44, 0xD4, 0xFC, 0xC9, 0x72, - 0xE3, 0xCE, 0x42, 0x7B, 0x33, 0x3E, 0xBC, 0x41, 0x61, 0x44, 0x81, 0x4D, 0x8A, 0x82, 0x46, 0xD4, - 0x7D, 0xAA, 0x32, 0xDE, 0x25, 0x42, 0x6A, 0xEE, 0xFF, 0xFF, 0xA3, 0x58, 0x60, 0x30, 0x03, 0x06, - 0x09, 0xE1, 0x8A, 0x69, 0x5A, 0x14, 0x06, 0x09, 0x01, 0xCE, 0x64, 0x88, 0x25, 0x86, 0x1A, 0x60, - 0x0E, 0x16, 0x1D, 0x99, 0xB8, 0x1A, 0x70, 0x45, 0xB9, 0xE4, 0xC7, 0x46, 0x01, 0x1B, 0x97, 0x70, - 0xC4, 0x61, 0xF3, 0x22, 0xAC, 0x4C, 0x42, 0x0D, 0x37, 0x69, 0x04, 0x10, 0x03, 0x0E, 0x0F, 0x0B, - 0x6D, 0x94, 0xB1, 0x56, 0xFA, 0x1C, 0x8B, 0x27, 0x62, 0x80, 0x24, 0xBA, 0xA9, 0x09, 0x3D, 0xC7, - 0x38, 0x15, 0xAF, 0xB6, 0x24, 0x86, 0x47, 0x18, 0x48, 0x72, 0xC0, 0x3E, 0x0C, 0xA0, 0xC0, 0x59, - 0xD5, 0xEB, 0xB0, 0xC2, 0x6B, 0x51, 0xA7, 0x13, 0x60, 0x0E, 0x88, 0x41, 0x84, 0x96, 0x95, 0xB1, - 0xD4, 0x5E, 0x55, 0x24, 0x3A, 0xAA, 0x54, 0x7C, 0x4E, 0x35, 0x8C, 0x95, 0x89, 0xF7, 0x19, 0x7E, - 0x63, 0x5A, 0xA3, 0x5C, 0x75, 0xA8, 0xE3, 0x2F, 0xED, 0x78, 0xCC, 0xE5, 0x32, 0xAF, 0x96, 0xE5, - 0xDC, 0x77, 0x4B, 0x8E, 0x35, 0x60, 0x86, 0x9F, 0x84, 0xAA, 0xE4, 0x6A, 0x7A, 0x9B, 0x2C, 0xB2, - 0xFF, 0xB9, 0x0D, 0x4F, 0x7F, 0xA1, 0xDE, 0x45, 0x36, 0xA8, 0x81, 0x01, 0x80, 0x90, 0x00, 0x05, - 0xBA, 0x03, 0xF9, 0x0B, 0x26, 0xFC, 0xA4, 0x51, 0xBB, 0xA0, 0x96, 0x5D, 0xDD, 0xF8, 0x66, 0x7D, - 0xF5, 0x26, 0x9C, 0xDF, 0xFA, 0xFD, 0xB9, 0x5C, 0x08, 0x53, 0xBB, 0x4A, 0x6F, 0x9B, 0xFF, 0xFF, - 0x9D, 0xE6, 0x79, 0x51, 0x74, 0x72, 0x12, 0x01, 0x3A, 0xAA, 0x00, 0x0F, 0x03, 0x0A, 0x45, 0x43, - 0x19, 0x94, 0xB3, 0xFB, 0x89, 0x23, 0x15, 0x87, 0xB3, 0x67, 0xD2, 0x73, 0x21, 0xC2, 0x23, 0x0D, - 0xCC, 0x73, 0x75, 0xD1, 0x53, 0x2A, 0x07, 0x33, 0x8D, 0x8D, 0xC4, 0xB5, 0x30, 0xE4, 0xCF, 0xFF, - 0xFB, 0x92, 0x64, 0x12, 0x8C, 0x44, 0xAD, 0x2C, 0x49, 0x93, 0xB8, 0x6B, 0xE0, 0x31, 0x27, 0x99, - 0x93, 0x14, 0x22, 0xBA, 0x11, 0x34, 0xD1, 0x2A, 0x4E, 0xE0, 0xCF, 0x80, 0xC6, 0x24, 0x27, 0x28, - 0x70, 0x89, 0xF8, 0x32, 0x10, 0x05, 0x30, 0x04, 0x37, 0x36, 0xAC, 0x13, 0x31, 0x74, 0x90, 0x28, - 0x11, 0xCC, 0x1B, 0x0D, 0x50, 0x79, 0xF5, 0x64, 0xCB, 0xC0, 0x2C, 0xC0, 0x83, 0x48, 0x21, 0x85, - 0xF6, 0x8A, 0x4F, 0x1A, 0x74, 0x8E, 0xA0, 0x48, 0xCC, 0xC1, 0x0D, 0x06, 0x4C, 0x84, 0xF0, 0x52, - 0x0F, 0x42, 0x97, 0x17, 0x51, 0x1E, 0xD8, 0x3E, 0x54, 0xAA, 0x03, 0x1D, 0x5F, 0x93, 0x48, 0x22, - 0x02, 0xB4, 0xD4, 0x91, 0x23, 0xB9, 0x2B, 0x03, 0x0E, 0x84, 0x68, 0xA2, 0x69, 0x58, 0x5F, 0x64, - 0xF8, 0x65, 0x6B, 0x1A, 0x3B, 0x3B, 0x3B, 0x7A, 0x0D, 0x0B, 0xE3, 0xA2, 0x8A, 0xD2, 0xA8, 0xBE, - 0x0A, 0xAF, 0xF5, 0x95, 0x03, 0x98, 0x2C, 0x77, 0xA5, 0x84, 0x93, 0x59, 0xDA, 0x8C, 0x6E, 0x35, - 0xD6, 0xCC, 0xD0, 0xA0, 0x00, 0x07, 0xB0, 0x0D, 0xFE, 0x02, 0x0E, 0xFD, 0x87, 0x64, 0x52, 0xB3, - 0x14, 0xE9, 0x32, 0xCE, 0x76, 0x17, 0x8E, 0xFC, 0xA6, 0x76, 0x38, 0xB8, 0x88, 0x91, 0x3F, 0xFF, - 0x35, 0xFE, 0x29, 0xF5, 0xF8, 0x38, 0xCD, 0x09, 0x6C, 0x8F, 0x11, 0x8D, 0x08, 0x53, 0x30, 0x86, - 0x19, 0x7B, 0x1B, 0x40, 0x1C, 0x02, 0xAC, 0x04, 0x60, 0x99, 0x86, 0x8C, 0x81, 0xF1, 0xC2, 0x19, - 0x91, 0x07, 0x01, 0x8E, 0x40, 0x19, 0x88, 0xC4, 0x21, 0x83, 0x25, 0xE8, 0x3A, 0x7B, 0x28, 0x23, - 0x8C, 0x79, 0x46, 0xC7, 0x01, 0x90, 0x00, 0x0E, 0x62, 0x98, 0x28, 0x20, 0x0B, 0xCC, 0xE2, 0x2F, - 0x80, 0x49, 0x62, 0x68, 0x8E, 0x06, 0x63, 0x4C, 0x56, 0x96, 0x50, 0xE8, 0x3A, 0x0C, 0xB5, 0x7A, - 0xD1, 0x43, 0x4E, 0xB2, 0xB7, 0x25, 0x73, 0x96, 0xAB, 0xA3, 0x09, 0x0A, 0x8D, 0xAD, 0x79, 0x80, - 0x08, 0xD0, 0x2D, 0x34, 0x6E, 0x51, 0xE8, 0x0B, 0x6E, 0xB4, 0x39, 0x72, 0x92, 0x00, 0x38, 0x09, - 0x91, 0x19, 0x4B, 0x15, 0x08, 0x02, 0xB9, 0x4A, 0x25, 0x2B, 0x4E, 0x36, 0x4B, 0x17, 0x7D, 0x1D, - 0xB7, 0x76, 0x5B, 0x22, 0xBF, 0xBC, 0x25, 0x51, 0xE1, 0x6F, 0xCD, 0x85, 0x33, 0xF7, 0x6C, 0x9E, - 0x70, 0x56, 0xF8, 0xCF, 0xFF, 0x72, 0x77, 0x11, 0xC9, 0x93, 0xFF, 0xFE, 0x2E, 0xDD, 0xF1, 0x40, - 0x08, 0x16, 0x7E, 0x01, 0x76, 0x3C, 0xFA, 0xBE, 0x20, 0x6D, 0xA8, 0x67, 0x68, 0x24, 0xB2, 0x27, - 0x71, 0x00, 0xC8, 0x99, 0x8B, 0xF3, 0x55, 0x1B, 0x22, 0xE4, 0xFF, 0x09, 0x7E, 0xEF, 0xFF, 0xDF, - 0xF7, 0x3A, 0xE4, 0x1D, 0xA7, 0x72, 0x39, 0x48, 0xDC, 0x9F, 0x5F, 0xFD, 0x96, 0x7E, 0x90, 0x4F, - 0x02, 0x0C, 0x18, 0x0B, 0x4C, 0x6B, 0x59, 0x8F, 0x99, 0x8E, 0xCC, 0x63, 0x22, 0x81, 0xA9, 0x99, - 0x87, 0xC0, 0x19, 0x83, 0x60, 0xC1, 0x86, 0x49, 0x11, 0x92, 0x03, 0xD1, 0xA0, 0x85, 0x70, 0xC0, - 0x30, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8E, 0x04, 0x5F, 0x34, 0xCA, 0x8B, 0xB8, 0x3B, 0xE4, 0x33, - 0x27, 0x0A, 0x6D, 0x0C, 0x22, 0x1C, 0x91, 0xF4, 0xD3, 0x2C, 0x4E, 0xEF, 0x03, 0x50, 0xC9, 0x04, - 0xE9, 0x28, 0x60, 0x89, 0x02, 0x61, 0xC0, 0xB2, 0x62, 0x28, 0xF4, 0x61, 0x39, 0x82, 0x63, 0x49, - 0x0A, 0x62, 0x80, 0x82, 0xF2, 0x8B, 0x01, 0x04, 0x50, 0x67, 0x6E, 0x9A, 0x3D, 0xB7, 0x45, 0x34, - 0x81, 0x25, 0x4D, 0x32, 0x85, 0x5F, 0xA7, 0xCA, 0xB0, 0xA8, 0xAA, 0xF9, 0x4E, 0xB2, 0x41, 0x87, - 0x09, 0x07, 0x59, 0x31, 0x01, 0x95, 0xF2, 0x82, 0x32, 0x98, 0x2D, 0x23, 0xF9, 0xA7, 0x81, 0x2A, - 0x15, 0x55, 0x4C, 0xC4, 0x46, 0x5A, 0x42, 0x36, 0x00, 0xD6, 0x04, 0x10, 0x8D, 0xC9, 0xF7, 0x0A, - 0x58, 0x47, 0x4D, 0xB7, 0x67, 0x53, 0xEF, 0x75, 0x3F, 0x64, 0x82, 0xD2, 0x63, 0xF6, 0x1C, 0xE7, - 0x9C, 0xDC, 0xFF, 0xC7, 0x4A, 0x11, 0xF5, 0x14, 0x17, 0x12, 0x0B, 0x89, 0xC1, 0x30, 0x00, 0x2C, - 0x80, 0x45, 0x01, 0x13, 0x4C, 0x2B, 0x36, 0x01, 0xCD, 0x45, 0x9C, 0x6E, 0x53, 0x8E, 0xD4, 0x65, - 0x67, 0xCC, 0x11, 0x74, 0xDF, 0x70, 0xC6, 0x62, 0x34, 0x8D, 0xFF, 0x77, 0x3B, 0xA3, 0x7F, 0x71, - 0x79, 0x3E, 0x6F, 0x4F, 0xEF, 0xF5, 0xB9, 0x58, 0xF2, 0x74, 0x47, 0x51, 0xF3, 0x8F, 0xF5, 0x39, - 0x4A, 0x7D, 0x09, 0x08, 0x08, 0x00, 0xE3, 0x10, 0x56, 0xD3, 0xA1, 0xDC, 0xA3, 0x26, 0xC9, 0x13, - 0xE2, 0x7E, 0x35, 0x83, 0x23, 0x0B, 0x66, 0x36, 0x68, 0x93, 0x5B, 0x36, 0x30, 0xB1, 0x42, 0x41, - 0xF4, 0xFA, 0x37, 0x85, 0x03, 0xAE, 0x80, 0x30, 0xA4, 0xF2, 0x37, 0x27, 0x10, 0x64, 0x69, 0x66, - 0x48, 0xDD, 0xF6, 0xE3, 0x16, 0x22, 0x04, 0x45, 0xF7, 0x8B, 0x33, 0x5B, 0x8A, 0x5E, 0x84, 0xE2, - 0xD0, 0x25, 0xFB, 0xFF, 0x48, 0x9F, 0xE2, 0x23, 0x33, 0x34, 0x5E, 0x41, 0x74, 0xAB, 0xCB, 0x8B, - 0xF2, 0x5C, 0xE5, 0xB1, 0xA4, 0xB8, 0x52, 0xF6, 0xDC, 0x48, 0xCD, 0xC1, 0x9B, 0xB0, 0xD4, 0x97, - 0x4C, 0x24, 0x4D, 0x86, 0x88, 0x40, 0x91, 0x6C, 0x1A, 0x36, 0xFF, 0x3D, 0x10, 0x9C, 0xDF, 0xA9, - 0xDB, 0x13, 0x5F, 0x6E, 0x9F, 0xFF, 0xF9, 0xDE, 0x7F, 0xDC, 0xB1, 0xFF, 0xFF, 0xBC, 0xA5, 0x32, - 0x38, 0xE5, 0x8F, 0xFF, 0xD4, 0xCD, 0x15, 0x14, 0xBD, 0x87, 0xC4, 0xA5, 0x7C, 0xFF, 0xA9, 0x94, - 0x57, 0xBC, 0x64, 0x06, 0x07, 0x20, 0x82, 0xE4, 0xC0, 0x04, 0x24, 0x72, 0x66, 0x4D, 0x7A, 0xBA, - 0x83, 0x62, 0xD0, 0x52, 0x41, 0x11, 0x30, 0x2B, 0x53, 0x16, 0xBE, 0x1C, 0x96, 0xAB, 0xDD, 0x99, - 0xB6, 0x8B, 0x4A, 0xF2, 0xA6, 0xE5, 0x44, 0xA8, 0x6F, 0x57, 0xAC, 0x40, 0xB1, 0x33, 0xC5, 0x47, - 0x84, 0xE1, 0xF2, 0x0D, 0x3A, 0x00, 0x02, 0x03, 0x02, 0xC0, 0x43, 0x0F, 0x8C, 0x73, 0xA3, 0x07, - 0xC3, 0x1B, 0x89, 0xF0, 0x1D, 0x71, 0x99, 0x0F, 0x9A, 0xD9, 0xB9, 0xA1, 0xB9, 0x18, 0x98, 0xE9, - 0xA0, 0xDE, 0x1A, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0E, 0x04, 0x67, 0x34, 0x4C, 0x13, 0xBB, 0xD0, - 0xA4, 0x33, 0x48, 0xBA, 0x5D, 0x08, 0xC5, 0x80, 0x90, 0xEC, 0xD1, 0x36, 0x4E, 0x64, 0xED, 0xD0, - 0xCD, 0x07, 0xA8, 0x74, 0x11, 0x98, 0x3A, 0x70, 0x21, 0x40, 0xA7, 0xAD, 0x20, 0xC1, 0xF3, 0x38, - 0x54, 0xD6, 0x14, 0x30, 0xC3, 0x94, 0x15, 0xCC, 0x86, 0xD7, 0x1C, 0xB1, 0x25, 0xD7, 0xEC, 0x9D, - 0xE0, 0x94, 0x47, 0xE4, 0x30, 0xE3, 0xB8, 0x54, 0x1D, 0x54, 0xB7, 0xAC, 0xA4, 0xBB, 0xED, 0x1A, - 0x24, 0xBF, 0x5F, 0x25, 0xF5, 0x18, 0xA8, 0xFD, 0xFA, 0xF0, 0x51, 0xC5, 0xF0, 0x88, 0xA3, 0xA5, - 0xDA, 0xD9, 0x7E, 0xD1, 0x18, 0x58, 0x1B, 0xC4, 0x17, 0x0C, 0xA6, 0xED, 0xA4, 0x4A, 0x5F, 0x00, - 0x5E, 0x74, 0x25, 0x58, 0xF7, 0x9D, 0xDD, 0x9F, 0xA5, 0xCB, 0xFF, 0xE2, 0x70, 0x3D, 0xE8, 0xDF, - 0x68, 0x31, 0xFF, 0xFF, 0xA9, 0x44, 0xF3, 0x53, 0x43, 0x94, 0x5F, 0xFF, 0xF2, 0xFA, 0xAF, 0x4C, - 0x37, 0x66, 0x6E, 0x2C, 0xEF, 0xD5, 0x08, 0x00, 0x80, 0xE0, 0x28, 0x0A, 0x9E, 0x00, 0x58, 0xBA, - 0xB3, 0x95, 0x9E, 0x86, 0xAA, 0xBE, 0xF8, 0x71, 0x6B, 0xAC, 0xF6, 0xA3, 0x2A, 0xCB, 0xBD, 0x8B, - 0xE7, 0xFF, 0xF6, 0xFF, 0x97, 0xA0, 0xD0, 0x0C, 0x1D, 0x84, 0x3F, 0xE7, 0xFF, 0xDF, 0xFF, 0xFE, - 0xD2, 0x2D, 0xC6, 0x0F, 0xED, 0x3E, 0xC6, 0x12, 0xCA, 0x06, 0x02, 0x80, 0xB0, 0xA9, 0xE8, 0xE1, - 0x4D, 0xF1, 0xA3, 0x01, 0x94, 0xDC, 0x27, 0x1D, 0x3D, 0xA2, 0x90, 0x29, 0xF8, 0x02, 0x07, 0x18, - 0x4C, 0x56, 0x64, 0x30, 0x82, 0x10, 0x19, 0x80, 0x8C, 0x64, 0x24, 0x68, 0x04, 0x16, 0x62, 0x3E, - 0x74, 0x8A, 0xAD, 0x89, 0xD7, 0x0B, 0x5A, 0xAB, 0xAD, 0x63, 0x96, 0x81, 0x3A, 0x1B, 0x8C, 0x06, - 0xD4, 0x67, 0x01, 0x02, 0x15, 0x11, 0x36, 0xCB, 0x19, 0x04, 0x15, 0x18, 0x70, 0x73, 0x2B, 0xA1, - 0xCF, 0x8B, 0x58, 0x9F, 0x94, 0x48, 0x65, 0x97, 0xDC, 0xA3, 0x10, 0x27, 0x90, 0xC8, 0x49, 0x04, - 0x10, 0x23, 0x32, 0x64, 0x33, 0xD2, 0x38, 0xF5, 0xE7, 0xF2, 0x77, 0x3A, 0x99, 0xB9, 0x6C, 0x5E, - 0xFF, 0xFF, 0xFC, 0x1E, 0x06, 0x0C, 0x1F, 0x24, 0xAF, 0x99, 0x11, 0xC6, 0xE0, 0xF0, 0x02, 0xC2, - 0xA4, 0x51, 0x95, 0xC0, 0xF0, 0x26, 0x0F, 0x0F, 0x22, 0x03, 0x8F, 0x7F, 0xF3, 0x0A, 0xBF, 0xBE, - 0x90, 0x80, 0x10, 0x02, 0x80, 0x00, 0x92, 0x68, 0x16, 0x97, 0x01, 0x9B, 0x6C, 0xFE, 0x14, 0x4F, - 0x7E, 0x57, 0x40, 0x72, 0xB7, 0xB2, 0xCA, 0x4F, 0x56, 0x64, 0xAA, 0x43, 0x71, 0x64, 0x08, 0x4D, - 0x8D, 0x36, 0x21, 0x67, 0xD9, 0x90, 0xA4, 0xA0, 0x0B, 0x5C, 0xB7, 0xF9, 0x6A, 0x84, 0xAF, 0xB4, - 0x46, 0x34, 0x03, 0xBA, 0x90, 0x00, 0x41, 0x13, 0x60, 0xC6, 0xC2, 0x00, 0x08, 0xC2, 0x83, 0x84, - 0xCC, 0x70, 0x74, 0xC1, 0x01, 0x08, 0xE1, 0x61, 0x14, 0xC6, 0x70, 0x10, 0x42, 0x26, 0x98, 0xDE, - 0x08, 0x81, 0x42, 0xA0, 0x28, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8F, 0x04, 0x7E, 0x34, 0x4E, 0x83, - 0xBA, 0x7B, 0x60, 0x2E, 0x85, 0x99, 0x85, 0x1D, 0x02, 0x96, 0xD2, 0x10, 0xD3, 0x3C, 0x0E, 0xE5, - 0xEF, 0x40, 0xC1, 0x8B, 0x27, 0xA8, 0x84, 0x99, 0xCA, 0x2A, 0x62, 0x08, 0x84, 0x63, 0x8B, 0x34, - 0x62, 0x66, 0x48, 0x8E, 0xAB, 0x30, 0x31, 0x46, 0xD1, 0xC0, 0x76, 0x46, 0x87, 0x31, 0xC5, 0xA7, - 0x04, 0x3C, 0x49, 0x40, 0xDD, 0x14, 0xCD, 0x89, 0x90, 0x8E, 0x36, 0xA8, 0xD1, 0x9C, 0x54, 0xC2, - 0x10, 0x16, 0xB9, 0xBC, 0xA3, 0x82, 0x1B, 0x47, 0x05, 0xA4, 0x41, 0x8E, 0xDC, 0x4D, 0x54, 0x44, - 0x02, 0x8C, 0x29, 0xA3, 0x00, 0x74, 0x98, 0xD5, 0xC2, 0xD6, 0x35, 0x86, 0x70, 0xDC, 0x75, 0x27, - 0x05, 0x9C, 0xFF, 0x34, 0xDB, 0xC2, 0x0C, 0x03, 0x83, 0x84, 0x4F, 0xFF, 0xFF, 0xFF, 0xD8, 0xB0, - 0xB2, 0x87, 0x3C, 0xC4, 0x09, 0x7E, 0x0B, 0xBA, 0x7F, 0x48, 0x79, 0xD0, 0x7E, 0xCF, 0x24, 0xBD, - 0x81, 0xC1, 0x3E, 0xAE, 0xD8, 0xC2, 0x7C, 0xF1, 0x84, 0x04, 0x1B, 0x6F, 0x31, 0x88, 0x15, 0x73, - 0x3A, 0x78, 0x5C, 0x02, 0xC9, 0x8A, 0x01, 0xC2, 0xA7, 0x26, 0xED, 0xF1, 0xE9, 0x47, 0xB8, 0x08, - 0x06, 0x87, 0xDA, 0x4A, 0xF2, 0xB4, 0xD0, 0x14, 0x4C, 0xC2, 0x8D, 0xFF, 0xFE, 0x95, 0xD0, 0xF5, - 0x76, 0x06, 0x37, 0x9F, 0x9B, 0xC3, 0xE1, 0x82, 0x00, 0xBC, 0xCF, 0x80, 0x9C, 0xC1, 0x90, 0x6C, - 0x94, 0x9F, 0x32, 0x94, 0x0A, 0x11, 0x88, 0x86, 0xB8, 0xD3, 0x42, 0x46, 0xE1, 0x83, 0x40, 0x81, - 0x81, 0x61, 0x91, 0x08, 0x14, 0x60, 0xF8, 0x90, 0x15, 0x00, 0x4C, 0x4A, 0x43, 0x8C, 0xB2, 0x06, - 0x41, 0x80, 0x31, 0x8A, 0x41, 0xB0, 0x18, 0x19, 0xD8, 0x6A, 0x0F, 0x31, 0x0D, 0x95, 0xA8, 0x7A, - 0x91, 0x78, 0x14, 0xE7, 0x4D, 0x1C, 0x69, 0x10, 0xA1, 0x86, 0x71, 0x81, 0x1B, 0x00, 0x00, 0x43, - 0x9A, 0xEB, 0x4A, 0x3D, 0xB3, 0xC6, 0x52, 0xF4, 0xB4, 0xB9, 0x32, 0x76, 0xC3, 0x31, 0x54, 0xBF, - 0x28, 0x14, 0xCD, 0x14, 0xEF, 0x48, 0x80, 0x12, 0xEF, 0xA6, 0x2B, 0xFC, 0x65, 0x40, 0x30, 0xC4, - 0xF5, 0x80, 0xB6, 0x4C, 0x32, 0x47, 0xD8, 0xB6, 0x10, 0xCD, 0xFF, 0xFF, 0xFF, 0xF5, 0xDA, 0x99, - 0xB5, 0x65, 0x77, 0x6D, 0xBE, 0xF7, 0x3D, 0x5C, 0xD2, 0xAA, 0xE7, 0x03, 0x72, 0x7E, 0xCD, 0xD7, - 0x58, 0xB3, 0x9E, 0x1C, 0x99, 0x1F, 0xD0, 0xF4, 0x09, 0x40, 0x05, 0x60, 0x80, 0x24, 0xF5, 0xF5, - 0xDA, 0x47, 0x84, 0x0C, 0xF5, 0xB5, 0x7C, 0x8C, 0xDB, 0x30, 0x1A, 0x13, 0x0A, 0x77, 0x3F, 0xA1, - 0x9A, 0xF6, 0x17, 0xB3, 0x75, 0xBC, 0x1D, 0x56, 0xB3, 0x2C, 0x20, 0x10, 0x2E, 0x8F, 0x2E, 0x2B, - 0x45, 0x61, 0xA6, 0x83, 0x33, 0xA1, 0x27, 0xD5, 0x8B, 0xA6, 0x01, 0x9D, 0x21, 0xF1, 0x82, 0x01, - 0x79, 0x80, 0xA3, 0xE9, 0x99, 0x20, 0x49, 0x70, 0x0D, 0x28, 0xCA, 0xCC, 0x1C, 0x06, 0x4A, 0x81, - 0xF9, 0x94, 0xA0, 0xD8, 0xC0, 0x0C, 0x61, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x87, 0x24, 0x7B, 0x34, - 0xCE, 0x83, 0xBA, 0x7B, 0xD0, 0x32, 0x66, 0x69, 0xCC, 0x15, 0x25, 0x76, 0x51, 0x28, 0xD3, 0x3B, - 0x0E, 0xE9, 0x2F, 0x90, 0xC3, 0x9A, 0x26, 0xD0, 0x24, 0x96, 0x10, 0xC0, 0x76, 0x9E, 0xC6, 0x15, - 0xAF, 0x40, 0x62, 0x94, 0x78, 0x06, 0x33, 0x2C, 0x61, 0x0E, 0x51, 0x01, 0x17, 0xC2, 0x54, 0x60, - 0x43, 0x45, 0xC4, 0x44, 0xD8, 0xF3, 0x32, 0x22, 0x01, 0x81, 0x08, 0xB5, 0x2D, 0x02, 0x8A, 0x1E, - 0xAC, 0xA1, 0xA2, 0x2B, 0xC6, 0x08, 0x04, 0x25, 0x3C, 0x64, 0x4F, 0x13, 0x95, 0x1D, 0xB1, 0x93, - 0x61, 0x90, 0xCB, 0xD9, 0x4C, 0x32, 0x61, 0x1B, 0x84, 0x43, 0x11, 0x03, 0x6C, 0xD0, 0x32, 0xD0, - 0x9E, 0x00, 0x90, 0x23, 0x88, 0x84, 0xA1, 0xA4, 0x85, 0x27, 0x00, 0x05, 0xC1, 0xB6, 0x7F, 0xFF, - 0xFA, 0x44, 0x52, 0xBC, 0x57, 0x2A, 0xE6, 0xAE, 0x19, 0x7F, 0x71, 0x51, 0xB3, 0xA0, 0x15, 0x4C, - 0x9A, 0xCB, 0x87, 0x85, 0x59, 0x27, 0x33, 0xC6, 0x4A, 0xDA, 0xE3, 0x40, 0x02, 0x00, 0x80, 0x00, - 0x00, 0xC0, 0x0B, 0x16, 0xFA, 0x46, 0xA0, 0x80, 0x6F, 0x6F, 0x19, 0x75, 0x10, 0x94, 0x0A, 0xD1, - 0x92, 0x17, 0xA0, 0x40, 0x6F, 0xD0, 0x19, 0x15, 0x02, 0xA1, 0xD1, 0x8F, 0x56, 0x68, 0xAA, 0x80, - 0x8B, 0xFF, 0xAF, 0x93, 0xFF, 0x8E, 0xEF, 0xFB, 0xA5, 0x7F, 0xBC, 0x3E, 0x24, 0x2E, 0x00, 0x26, - 0x10, 0xAC, 0xCD, 0xC1, 0xE4, 0xC0, 0x20, 0x98, 0x0A, 0x23, 0x82, 0x99, 0xF3, 0x02, 0xC3, 0x03, - 0x47, 0xE5, 0x60, 0x20, 0x16, 0x60, 0xE8, 0x60, 0x4C, 0x43, 0x2A, 0xB1, 0x88, 0x63, 0x22, 0xAC, - 0x1C, 0x4E, 0x0C, 0xA6, 0x0A, 0x04, 0x80, 0x53, 0x1F, 0x07, 0x61, 0x40, 0xAA, 0x50, 0x50, 0x56, - 0x1E, 0x08, 0x13, 0x0C, 0x22, 0x08, 0xF0, 0x3C, 0xD1, 0xFE, 0x56, 0x54, 0x0E, 0xE1, 0x32, 0x91, - 0x90, 0x8F, 0xC8, 0xAC, 0xE3, 0x6C, 0x0D, 0xF8, 0x08, 0x0D, 0x26, 0x8F, 0x4F, 0x50, 0x46, 0xAA, - 0x5C, 0xC2, 0xED, 0x98, 0x7D, 0x4D, 0x80, 0xE3, 0xD9, 0x28, 0x50, 0x2A, 0xFE, 0x66, 0x4C, 0x43, - 0x8C, 0x4E, 0x84, 0x64, 0x04, 0xA6, 0x85, 0x15, 0xA2, 0xEC, 0xC4, 0x68, 0x3F, 0x7F, 0xFF, 0xFE, - 0x92, 0xF6, 0x65, 0xE2, 0x96, 0xEC, 0xDE, 0xDC, 0xD1, 0x00, 0x21, 0x08, 0x89, 0x60, 0xAB, 0xAF, - 0xF8, 0xB8, 0xFE, 0x0B, 0x52, 0xC4, 0x11, 0x2C, 0x60, 0x03, 0x00, 0x00, 0xB3, 0x74, 0x3C, 0xA5, - 0x43, 0x76, 0xF3, 0x49, 0xA4, 0x08, 0x53, 0x59, 0xED, 0x09, 0xEB, 0xD2, 0x24, 0xDA, 0x7F, 0xF7, - 0x61, 0x7F, 0x8D, 0x00, 0xC4, 0x71, 0x41, 0x70, 0xE0, 0xD6, 0x38, 0x73, 0xFE, 0xBB, 0xBA, 0xB7, - 0xCC, 0x64, 0x33, 0x7C, 0xA4, 0xA1, 0x84, 0xCC, 0x80, 0x00, 0x04, 0x32, 0x87, 0x73, 0x43, 0x48, - 0x21, 0x18, 0xA8, 0x60, 0x80, 0x8A, 0x24, 0xD7, 0x02, 0x04, 0xD3, 0x1B, 0x2D, 0x34, 0x8B, 0x00, - 0x02, 0x26, 0x87, 0x80, 0x64, 0xA0, 0x59, 0x84, 0xC4, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x87, 0x14, - 0x8D, 0x34, 0xCE, 0x2B, 0xBA, 0x7B, 0xD0, 0x2E, 0x45, 0xC9, 0xDD, 0x00, 0xC5, 0x66, 0x12, 0x2C, - 0xD3, 0x36, 0x0E, 0xE9, 0xEF, 0x40, 0xBC, 0x10, 0xA6, 0xF0, 0x13, 0x15, 0xD0, 0xB8, 0x14, 0x03, - 0x30, 0x1D, 0x7E, 0x32, 0xE0, 0x15, 0x48, 0x83, 0x1A, 0x45, 0x11, 0x18, 0x44, 0x5E, 0x1E, 0x08, - 0xEB, 0x18, 0x71, 0x0C, 0x51, 0x3B, 0xC3, 0x83, 0x44, 0xCC, 0x00, 0xA9, 0x40, 0xA0, 0xB1, 0xA2, - 0x92, 0xD1, 0x54, 0xAF, 0x09, 0x85, 0x70, 0x78, 0xCA, 0xB8, 0x25, 0x40, 0xB0, 0x75, 0x03, 0xDB, - 0x3A, 0xC6, 0x1E, 0xCD, 0xFD, 0xC9, 0xB4, 0xF8, 0x1C, 0x06, 0x13, 0x49, 0x83, 0x15, 0x11, 0x44, - 0xA5, 0x41, 0x01, 0x7E, 0x4D, 0x19, 0xD0, 0xD4, 0x4A, 0x8C, 0x17, 0x6A, 0xD0, 0xFD, 0x06, 0x36, - 0xB1, 0xFF, 0xFF, 0xED, 0xCF, 0x76, 0xDC, 0xB2, 0x65, 0x31, 0xBF, 0x13, 0x0C, 0x0E, 0x10, 0x61, - 0x26, 0xB2, 0xF3, 0x7F, 0xA4, 0x95, 0x6A, 0x02, 0xC6, 0xB6, 0x46, 0x89, 0x63, 0x80, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x28, 0x00, 0x06, 0x8F, 0xC5, 0x8A, 0x22, 0x48, 0x61, 0xE6, 0xC8, 0x9C, 0x05, - 0x24, 0xDF, 0x27, 0xDB, 0xA0, 0xEF, 0x8A, 0x8A, 0x19, 0x54, 0x70, 0xB1, 0xC4, 0x67, 0x08, 0x2F, - 0xF4, 0x6A, 0x3A, 0x9A, 0xDA, 0xDE, 0x56, 0x16, 0xD6, 0x74, 0x02, 0x2D, 0x2A, 0x1C, 0x01, 0xCD, - 0x18, 0x22, 0x4C, 0x03, 0x0A, 0xCC, 0x08, 0x19, 0x4C, 0xDD, 0x00, 0x0C, 0x0B, 0x03, 0x8C, 0x34, - 0xB9, 0x8C, 0x65, 0x00, 0x8C, 0x0D, 0x1C, 0xC2, 0x18, 0x75, 0x0B, 0x30, 0xA0, 0xD2, 0x04, 0x01, - 0xE6, 0x0D, 0xB3, 0x46, 0x95, 0x8A, 0xE0, 0x10, 0x48, 0x14, 0x62, 0x9A, 0xE1, 0x29, 0x28, 0x5E, - 0x76, 0x9C, 0x14, 0x56, 0xEE, 0xA0, 0x58, 0x18, 0xC6, 0x8C, 0x48, 0x25, 0x08, 0x56, 0xC1, 0xE9, - 0xB3, 0x71, 0x72, 0x21, 0x65, 0x50, 0x26, 0x55, 0xF2, 0x56, 0x97, 0xB1, 0xE5, 0xA8, 0x17, 0x03, - 0x7D, 0xC2, 0x56, 0x8E, 0xFD, 0xCE, 0x22, 0x83, 0xF4, 0x79, 0x92, 0x21, 0x68, 0x04, 0x91, 0x32, - 0xC7, 0xD8, 0x23, 0xD6, 0x11, 0x66, 0x46, 0xD4, 0xE2, 0x3C, 0x1F, 0x26, 0x09, 0xE2, 0x6E, 0xB8, - 0xFF, 0xFF, 0xFE, 0x58, 0xBB, 0xFF, 0xB8, 0x33, 0xB7, 0xBB, 0xC2, 0x9A, 0x67, 0xC5, 0x6E, 0x23, - 0x38, 0xE5, 0x2B, 0xF7, 0x5D, 0x9C, 0x45, 0xD0, 0xB9, 0x8A, 0x5F, 0x27, 0x6E, 0x8A, 0x14, 0x00, - 0x80, 0x00, 0x1C, 0x64, 0xBA, 0xCC, 0x6F, 0x9F, 0x91, 0x34, 0x9A, 0x2E, 0x07, 0x1C, 0x8B, 0x90, - 0x3C, 0x77, 0xC4, 0xFD, 0x1B, 0x41, 0x61, 0xFF, 0x14, 0x0E, 0x20, 0xFC, 0x62, 0x14, 0x42, 0x08, - 0xFE, 0x46, 0xAB, 0x10, 0x04, 0x17, 0x0C, 0xA3, 0x06, 0x81, 0x51, 0xE7, 0x2A, 0x80, 0x00, 0x05, - 0xD6, 0xB8, 0x66, 0x59, 0x04, 0x60, 0x40, 0xBE, 0x60, 0x09, 0x2A, 0x24, 0xA7, 0x8C, 0x07, 0x66, - 0x89, 0xC6, 0x2C, 0x4C, 0x64, 0xA1, 0x31, 0x84, 0x4C, 0x01, 0x00, 0xFF, 0xFB, 0x90, 0x64, 0x0F, - 0x0F, 0x34, 0x65, 0x34, 0x4E, 0x2B, 0xB9, 0x83, 0xE2, 0x31, 0xC6, 0x99, 0xA8, 0x1C, 0xC5, 0x76, - 0x11, 0x0C, 0xD3, 0x3A, 0x0E, 0x77, 0x2C, 0x10, 0xB8, 0x0E, 0x67, 0x94, 0x82, 0x99, 0x88, 0x26, - 0x30, 0x86, 0x20, 0xE1, 0xB4, 0x0A, 0x42, 0x1C, 0xAE, 0x31, 0x80, 0x81, 0xA1, 0x19, 0x0C, 0x82, - 0xF0, 0xE8, 0x09, 0xB6, 0x0C, 0xA6, 0xA5, 0x03, 0x43, 0x03, 0xD0, 0xBB, 0x82, 0x24, 0x61, 0x92, - 0x50, 0x00, 0xA0, 0xC2, 0xC1, 0x08, 0x3E, 0xCC, 0x44, 0xE4, 0x4D, 0x75, 0x90, 0x94, 0x97, 0x18, - 0x8E, 0x01, 0x83, 0x23, 0x62, 0xBF, 0x8E, 0x50, 0x00, 0xF0, 0xAA, 0xAC, 0x72, 0xBE, 0xEE, 0xA2, - 0x00, 0x70, 0xB1, 0xD5, 0x79, 0x2C, 0x66, 0x32, 0x6E, 0xB1, 0x88, 0x1D, 0xD3, 0x45, 0xB7, 0x8A, - 0x0C, 0xC9, 0xBD, 0x3D, 0x6A, 0x43, 0x2F, 0x12, 0x6B, 0x30, 0x92, 0xAB, 0x48, 0xDD, 0x02, 0x54, - 0xD9, 0xCF, 0x4C, 0xC8, 0x3C, 0x82, 0x13, 0x83, 0xE0, 0x09, 0xE7, 0x05, 0xC0, 0xB0, 0x56, 0x18, - 0x01, 0x04, 0x44, 0x09, 0xF5, 0xB5, 0x04, 0xE4, 0xC6, 0x75, 0xFD, 0x1E, 0xBC, 0xF0, 0x1B, 0x44, - 0x64, 0x0F, 0x57, 0x3D, 0x3E, 0xCE, 0x75, 0x4A, 0x37, 0xFC, 0xCC, 0x0C, 0x28, 0x6E, 0x88, 0x34, - 0x3B, 0x7F, 0x43, 0xFB, 0x74, 0x15, 0xF7, 0x7D, 0xFA, 0x9E, 0x82, 0xE2, 0x60, 0x8A, 0x20, 0xAE, - 0xF2, 0xEC, 0x35, 0x51, 0xFC, 0xC0, 0xC1, 0x23, 0x06, 0x9D, 0x45, 0x9F, 0xC6, 0x0F, 0x00, 0x1D, - 0xCA, 0xA0, 0x64, 0x30, 0x89, 0x80, 0x8E, 0xA6, 0x76, 0x0E, 0xAA, 0xB9, 0x8A, 0x8F, 0xAB, 0xAC, - 0xC7, 0xED, 0xF3, 0xA1, 0x43, 0x00, 0xE0, 0xE8, 0xC1, 0x90, 0x7C, 0x05, 0x34, 0x0A, 0x60, 0x82, - 0xEC, 0x0E, 0x35, 0x35, 0x58, 0x04, 0x3C, 0x32, 0xCA, 0x58, 0xF4, 0x6C, 0xC5, 0x0A, 0xD0, 0xE9, - 0x8B, 0xF1, 0xDE, 0x0E, 0x69, 0xDA, 0x43, 0xB2, 0x2C, 0x52, 0xA8, 0xBE, 0xE2, 0x33, 0xBF, 0xBA, - 0xC4, 0x82, 0x0D, 0x51, 0x27, 0x13, 0x31, 0x67, 0xAB, 0x20, 0x62, 0xF7, 0x50, 0xCA, 0x1D, 0xEE, - 0xBE, 0x27, 0x2E, 0x86, 0x59, 0x74, 0x91, 0x5D, 0x4F, 0xF3, 0xFF, 0xFF, 0x0C, 0xF9, 0xF7, 0xB7, - 0xFF, 0x77, 0xB5, 0x29, 0xF7, 0x73, 0x5C, 0xFD, 0xD8, 0x63, 0x9B, 0xEF, 0xD0, 0xBD, 0xDE, 0xDD, - 0xA8, 0xD9, 0xE9, 0x68, 0x9C, 0x25, 0xD9, 0x60, 0x40, 0x61, 0x83, 0xEC, 0x3B, 0x3F, 0xAD, 0x09, - 0x01, 0x04, 0xC8, 0x02, 0x37, 0x47, 0xFA, 0x20, 0xCF, 0x48, 0xF0, 0x37, 0xE5, 0x98, 0xF0, 0x54, - 0x3D, 0x20, 0xF9, 0xFF, 0x68, 0xB3, 0xC9, 0xEC, 0x18, 0x94, 0xD4, 0xD0, 0x98, 0x8F, 0xED, 0x48, - 0xEE, 0xB6, 0xEE, 0x2C, 0x34, 0x52, 0x70, 0x4B, 0x00, 0x07, 0x63, 0x44, 0x62, 0xA8, 0x03, 0x12, - 0xE6, 0x1E, 0x20, 0x60, 0x30, 0x02, 0x71, 0xD8, 0x6E, 0x61, 0xA0, 0x1C, 0x60, 0xA0, 0x0A, 0x65, - 0x50, 0x80, 0xAA, 0x06, 0x07, 0x1E, 0x82, 0x00, 0x50, 0x45, 0x2E, 0x9D, 0xFF, 0xFB, 0x92, 0x64, - 0x13, 0x0F, 0x04, 0x87, 0x34, 0xCD, 0x83, 0x7D, 0xD1, 0x40, 0x30, 0x62, 0x4A, 0x5E, 0x3C, 0x6D, - 0x18, 0x10, 0xF4, 0xD3, 0x36, 0x0E, 0x65, 0xEF, 0x40, 0xC5, 0x0D, 0x66, 0xA0, 0xC2, 0x99, 0x98, - 0x46, 0x42, 0x2C, 0x53, 0x02, 0x07, 0x32, 0x87, 0x8D, 0x78, 0xBD, 0x2B, 0x75, 0x26, 0x87, 0x8E, - 0x55, 0x49, 0x4A, 0xEE, 0x54, 0x2D, 0xB8, 0x82, 0x82, 0xD1, 0x28, 0xD0, 0xB2, 0x86, 0xAA, 0x86, - 0xAF, 0x90, 0x20, 0xE1, 0x90, 0x07, 0x1B, 0x43, 0x84, 0x73, 0xF9, 0xAC, 0xA9, 0x48, 0x48, 0x08, - 0x47, 0xB7, 0xE6, 0x76, 0x22, 0x9A, 0x28, 0xE9, 0xA9, 0x08, 0xE9, 0x40, 0x6E, 0xA4, 0xFE, 0xB6, - 0xD1, 0xE4, 0x16, 0x20, 0x5A, 0x09, 0x5D, 0x1F, 0xFF, 0xFD, 0xEC, 0xA4, 0xB3, 0xB9, 0x5D, 0xAD, - 0xFD, 0xC7, 0x0D, 0xDF, 0xFC, 0xA1, 0xBA, 0xF3, 0xF7, 0xD8, 0x44, 0x03, 0x10, 0x94, 0x58, 0x94, - 0xDC, 0xC1, 0xDB, 0x79, 0xA0, 0x60, 0xC0, 0xAD, 0x76, 0x72, 0x4C, 0xA6, 0x12, 0x00, 0x00, 0x50, - 0xA8, 0x1C, 0x01, 0x29, 0x32, 0x16, 0x77, 0xE3, 0x19, 0x5A, 0xF5, 0x46, 0xE1, 0x67, 0x53, 0x99, - 0x00, 0xED, 0x08, 0xB0, 0x5C, 0x86, 0x9A, 0x37, 0x31, 0x73, 0x73, 0xCE, 0x6A, 0x02, 0x3D, 0xE0, - 0x50, 0x6C, 0x42, 0x6F, 0x6D, 0x7A, 0x94, 0xFE, 0xEE, 0xAE, 0x9A, 0x65, 0x69, 0x48, 0x67, 0xC5, - 0x38, 0xC8, 0x14, 0x08, 0x97, 0x35, 0xD1, 0x98, 0x08, 0x09, 0x3F, 0x67, 0xEC, 0xCB, 0x63, 0x50, - 0xA0, 0xF4, 0xCA, 0xC5, 0xF1, 0x00, 0x68, 0xC8, 0x29, 0x53, 0x03, 0x0A, 0x0D, 0x09, 0x1D, 0x0B, - 0xAC, 0x8C, 0x10, 0x0F, 0x64, 0xA3, 0xDE, 0x26, 0x30, 0x30, 0x95, 0x9B, 0x20, 0x1A, 0x36, 0x1A, - 0x43, 0x8C, 0x0D, 0x11, 0x79, 0xFA, 0x5C, 0x28, 0x42, 0xAB, 0x29, 0xDC, 0xF3, 0x50, 0x71, 0x01, - 0x27, 0x07, 0x1E, 0xCD, 0x95, 0x41, 0xAE, 0x4E, 0xE7, 0xFF, 0x62, 0x5E, 0x44, 0xB0, 0x30, 0x74, - 0x15, 0x26, 0x45, 0xEB, 0x1F, 0x72, 0x0E, 0x09, 0x28, 0x11, 0x35, 0x76, 0x35, 0x4A, 0x81, 0xA0, - 0xC0, 0x63, 0x68, 0xB7, 0xFF, 0xC7, 0xAB, 0xD9, 0x27, 0x51, 0xB1, 0xFF, 0xFE, 0xB1, 0xF2, 0x7C, - 0x37, 0x3C, 0x9D, 0x68, 0x57, 0x92, 0x0A, 0x85, 0x1C, 0x64, 0x0F, 0x2A, 0x5F, 0xB0, 0x06, 0xA8, - 0x43, 0xF2, 0xE2, 0x84, 0x00, 0x00, 0x00, 0xB4, 0xAC, 0x7F, 0xA0, 0xB2, 0x0C, 0xFA, 0x57, 0x9F, - 0xA9, 0xEC, 0x8A, 0x80, 0x7E, 0x93, 0x07, 0x9C, 0xA6, 0xF3, 0x38, 0x28, 0x4F, 0x06, 0x8D, 0x2D, - 0x55, 0xBF, 0xFE, 0xC2, 0x57, 0xDA, 0x80, 0x42, 0x84, 0xB3, 0xB2, 0xAE, 0xCB, 0x74, 0xEF, 0x80, - 0x0F, 0x9C, 0xA6, 0x0A, 0xD5, 0x86, 0x48, 0x41, 0x63, 0x13, 0x4D, 0x23, 0x03, 0x01, 0x53, 0x02, - 0x80, 0x40, 0x54, 0xA2, 0x60, 0x50, 0x74, 0x66, 0x1D, 0x54, 0x63, 0xC0, 0xD0, 0x20, 0x00, 0x07, - 0x85, 0xA3, 0x08, 0xC1, 0xB3, 0x03, 0x51, 0x52, 0xB1, 0xDC, 0x28, 0x0C, 0x99, 0xEC, 0xFF, 0xFB, - 0x92, 0x64, 0x14, 0x8F, 0x14, 0x5C, 0x34, 0xCD, 0x83, 0xB8, 0x7C, 0x50, 0x31, 0x26, 0x09, 0x69, - 0x18, 0xE6, 0x8C, 0x10, 0xE0, 0xD3, 0x36, 0x0E, 0x65, 0xED, 0x80, 0xCD, 0x19, 0xA6, 0x50, 0x72, - 0x8E, 0x31, 0x3B, 0x94, 0x02, 0x05, 0x50, 0x48, 0x88, 0x51, 0xF2, 0xD7, 0x4A, 0x67, 0x06, 0xB9, - 0x1C, 0x43, 0xA6, 0x70, 0x0C, 0x39, 0x3C, 0x40, 0x55, 0x96, 0x88, 0x64, 0xC2, 0x89, 0xAD, 0x48, - 0x65, 0x40, 0x80, 0xA8, 0x89, 0x4B, 0x03, 0x0B, 0xFA, 0xFF, 0xBE, 0xB0, 0xE5, 0x5E, 0xA9, 0x09, - 0x42, 0xD1, 0x6E, 0xE0, 0x94, 0x0B, 0xB1, 0x50, 0x09, 0x17, 0x5B, 0x7A, 0xE4, 0x31, 0x28, 0xC4, - 0x05, 0x47, 0x16, 0xFF, 0xFF, 0xD4, 0x4A, 0x3E, 0x86, 0xF5, 0x5D, 0xFD, 0xF5, 0xEF, 0x55, 0x19, - 0xE2, 0x40, 0xD6, 0x76, 0x5F, 0x0D, 0xE4, 0x39, 0xC4, 0xD2, 0x4E, 0x56, 0xF3, 0x23, 0x86, 0xFA, - 0x0C, 0x1B, 0xC2, 0x97, 0x80, 0x10, 0x01, 0x80, 0x30, 0x03, 0xC5, 0x9A, 0x8D, 0x6F, 0x7A, 0xF9, - 0x4E, 0xC4, 0xAE, 0xE0, 0x40, 0xCE, 0xBF, 0x46, 0x74, 0x77, 0xCF, 0x75, 0x54, 0xFA, 0x01, 0xC2, - 0xE1, 0xC3, 0x1C, 0xD5, 0x33, 0xA1, 0x8D, 0xD0, 0xC6, 0x5F, 0xB7, 0xFF, 0x9D, 0x88, 0x64, 0x10, - 0x98, 0xF7, 0x7A, 0x03, 0x6C, 0xBC, 0xA8, 0x40, 0x05, 0x32, 0xBC, 0x06, 0x1E, 0x06, 0xA7, 0x8C, - 0x08, 0x87, 0x01, 0x0C, 0x0D, 0x07, 0x49, 0x3C, 0x11, 0x68, 0xA8, 0x46, 0x33, 0x41, 0x08, 0x60, - 0x4E, 0x64, 0x01, 0xC8, 0xD6, 0x8C, 0xC2, 0x00, 0x23, 0x43, 0x05, 0x36, 0x2D, 0x10, 0xB5, 0xAF, - 0xEB, 0xF3, 0x55, 0x6C, 0x16, 0x4E, 0x79, 0x79, 0x4A, 0xEE, 0x23, 0x2B, 0xE6, 0xB0, 0x60, 0x23, - 0x16, 0x4A, 0x24, 0xD1, 0x37, 0x46, 0x34, 0xE8, 0xA7, 0xF2, 0xD3, 0x6E, 0x49, 0xA5, 0x62, 0xEF, - 0x75, 0x4A, 0xB5, 0x07, 0x17, 0x1E, 0xF2, 0x7E, 0xC8, 0x20, 0x24, 0x12, 0x0A, 0x36, 0x33, 0x0B, - 0x93, 0x27, 0x3B, 0x5D, 0x73, 0x9D, 0x4D, 0x3C, 0x1F, 0xF1, 0xAB, 0xC3, 0x89, 0x0B, 0x72, 0xC6, - 0x65, 0x93, 0xC1, 0x85, 0xE0, 0xC7, 0x1C, 0xA4, 0xC1, 0x3A, 0x44, 0x16, 0x34, 0x52, 0x84, 0xC6, - 0xB1, 0xC2, 0x5F, 0xAC, 0xF2, 0x51, 0xD8, 0xCC, 0x5F, 0x09, 0x38, 0xE2, 0xC8, 0x0C, 0x01, 0x10, - 0xC1, 0x41, 0x79, 0x7A, 0xFF, 0xD7, 0x02, 0x8E, 0x50, 0x9F, 0xAF, 0x39, 0x33, 0x9D, 0xCE, 0xEA, - 0x12, 0x1F, 0x9C, 0xF4, 0x31, 0x03, 0xE3, 0xB1, 0xA3, 0x94, 0x3F, 0x18, 0x8D, 0x56, 0x41, 0xFF, - 0xA7, 0xF2, 0x07, 0x2A, 0x00, 0x00, 0x44, 0x10, 0x5D, 0x08, 0xB0, 0x04, 0xE7, 0x0E, 0x08, 0x80, - 0x4C, 0x13, 0x02, 0x43, 0x63, 0x4C, 0x93, 0x00, 0x84, 0x48, 0xC3, 0x10, 0x88, 0xE1, 0x70, 0x24, - 0xC4, 0xF1, 0x6C, 0xC9, 0xFE, 0x84, 0xFD, 0x83, 0x8D, 0x01, 0x10, 0xC2, 0xD3, 0xCC, 0x40, 0x14, - 0xD9, 0xE2, 0x8E, 0xDC, 0xF0, 0x48, 0x70, 0xB4, 0x61, 0x92, 0x0D, 0x10, 0x4D, 0x4D, 0x04, 0x4A, - 0xFF, 0xFB, 0x92, 0x64, 0x18, 0x0F, 0x04, 0xBA, 0x34, 0xCC, 0x03, 0xBB, 0xC9, 0xA0, 0x2F, 0x86, - 0x89, 0xC8, 0x15, 0x02, 0x68, 0x12, 0x8C, 0xCF, 0x30, 0x0E, 0xEB, 0x08, 0xC8, 0xCB, 0x19, 0xE6, - 0xE0, 0x71, 0x89, 0xB0, 0x4A, 0xB9, 0x88, 0x0E, 0x91, 0x2F, 0xA6, 0x2F, 0x9A, 0x95, 0x29, 0x24, - 0xE9, 0x02, 0x9F, 0x15, 0x5D, 0x88, 0x0C, 0x7E, 0x90, 0x43, 0x2C, 0x94, 0x8F, 0x7C, 0xA4, 0xDD, - 0xD6, 0x03, 0x2E, 0x5D, 0x19, 0xC1, 0x8B, 0x6D, 0x42, 0x4C, 0x3C, 0x04, 0xEF, 0x8A, 0x03, 0x1B, - 0x07, 0x28, 0x14, 0x54, 0xE0, 0x00, 0x0C, 0x83, 0x40, 0x90, 0x59, 0x5C, 0x39, 0xA6, 0x8C, 0x27, - 0xBF, 0xFF, 0x25, 0xAB, 0x6A, 0x51, 0x4C, 0xE3, 0x6A, 0x67, 0x2C, 0xA2, 0x59, 0x55, 0x88, 0xF3, - 0xED, 0xCF, 0x21, 0x5B, 0xC8, 0x8F, 0xE5, 0xC0, 0x7A, 0x0B, 0xC0, 0xD5, 0xE2, 0x0D, 0x5D, 0x90, - 0xD2, 0xC7, 0xEB, 0xCC, 0xA1, 0x62, 0x03, 0xC2, 0xE0, 0x3F, 0x37, 0x80, 0x00, 0x30, 0x00, 0x0C, - 0x02, 0x8B, 0x43, 0x8D, 0xFE, 0xAF, 0xB0, 0x54, 0xA6, 0xFF, 0x81, 0xDC, 0x39, 0x47, 0xC8, 0xC6, - 0x64, 0x9E, 0x6B, 0x11, 0xF5, 0x70, 0xB6, 0x21, 0x54, 0x38, 0x2A, 0x20, 0xEC, 0xBF, 0xA7, 0xFE, - 0xFD, 0x11, 0xA3, 0x91, 0x82, 0xBD, 0x5D, 0x68, 0xCA, 0xA0, 0xD9, 0x47, 0x8C, 0x00, 0x0D, 0x4D, - 0xBD, 0x1E, 0x8C, 0x96, 0x0E, 0xCC, 0x57, 0x58, 0x4C, 0xFD, 0x34, 0x0C, 0x1B, 0x0B, 0xCD, 0x62, - 0x92, 0x4D, 0x3F, 0x03, 0x4C, 0x2C, 0x0D, 0xCE, 0x02, 0x00, 0x20, 0x63, 0x35, 0x2C, 0x46, 0xD4, - 0x52, 0x68, 0x55, 0xA8, 0xF0, 0x51, 0xE3, 0x21, 0x11, 0x27, 0xA9, 0x62, 0x08, 0x0C, 0x56, 0xF8, - 0x42, 0xC1, 0xBA, 0xCD, 0x95, 0x5D, 0x30, 0x24, 0x0C, 0x2E, 0x74, 0x68, 0x28, 0x54, 0x58, 0x2F, - 0x10, 0x61, 0x25, 0x84, 0xB7, 0x29, 0x02, 0xEB, 0x33, 0x0D, 0x95, 0x4F, 0x30, 0x7A, 0x38, 0xF3, - 0xB4, 0xD6, 0x8C, 0x20, 0x54, 0xEE, 0x7B, 0x07, 0x41, 0x91, 0xAB, 0x08, 0xE0, 0x5B, 0x71, 0xEA, - 0x37, 0x65, 0x18, 0x86, 0xA0, 0x06, 0x17, 0x3B, 0x6B, 0x9F, 0xF1, 0xF8, 0xFD, 0x1C, 0x71, 0x64, - 0xBE, 0xBC, 0xCB, 0xFF, 0x9A, 0xAA, 0xF7, 0xF7, 0x98, 0x40, 0x28, 0xAB, 0x25, 0x5B, 0x29, 0x02, - 0xD6, 0x53, 0x2A, 0x45, 0xDB, 0xF4, 0xD6, 0xA0, 0xAA, 0xF4, 0x71, 0xA7, 0xDD, 0x1F, 0x45, 0xC0, - 0x00, 0x00, 0x14, 0x08, 0xC3, 0x67, 0x60, 0x73, 0xFF, 0x14, 0x0F, 0x67, 0x35, 0x71, 0x7C, 0x33, - 0xAE, 0x48, 0x38, 0x52, 0xDF, 0x53, 0x0E, 0x32, 0x84, 0x14, 0x68, 0x3A, 0xF0, 0x53, 0x8E, 0xE1, - 0x1C, 0x5A, 0xB4, 0xA5, 0xFE, 0x7B, 0x04, 0xFC, 0xAF, 0xE1, 0xD6, 0xCC, 0x25, 0xF5, 0x6A, 0x55, - 0x00, 0x51, 0x51, 0xE1, 0x42, 0x09, 0xE8, 0x32, 0x66, 0x9D, 0x29, 0x19, 0xB2, 0x5E, 0x62, 0x96, - 0x28, 0xC8, 0xD0, 0x13, 0xF2, 0x39, 0xEB, 0x8E, 0x75, 0x43, 0x05, 0x14, 0x2E, 0x1C, 0xCD, 0x01, - 0x2D, 0x01, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x0F, 0xB4, 0x48, 0x34, 0xCC, 0x03, 0x9A, 0xC1, 0xB0, - 0x30, 0x26, 0x79, 0x80, 0x14, 0xC2, 0x6C, 0x50, 0x88, 0xD1, 0x32, 0x0E, 0xE9, 0xE9, 0xC0, 0xC7, - 0x99, 0xE4, 0xA0, 0x73, 0x2A, 0x10, 0x92, 0x16, 0x19, 0x44, 0x8A, 0x9A, 0x5A, 0x04, 0x16, 0x1F, - 0x78, 0xEF, 0xA3, 0x33, 0x50, 0x8E, 0xC6, 0x6C, 0xCB, 0x53, 0xAD, 0xB9, 0x0F, 0x09, 0x56, 0x09, - 0x30, 0x0F, 0x96, 0x06, 0xC6, 0x11, 0xE5, 0xE0, 0x00, 0x64, 0x22, 0x2F, 0x28, 0x2D, 0xF0, 0x14, - 0x9A, 0xBD, 0x25, 0x4A, 0x02, 0xFC, 0xB3, 0xE3, 0x68, 0x20, 0x78, 0x1D, 0x69, 0x37, 0x55, 0x14, - 0x5D, 0xED, 0x75, 0x04, 0x8A, 0x86, 0x5A, 0xE9, 0x3D, 0x5A, 0xCA, 0xDF, 0xFC, 0x66, 0xC4, 0x6E, - 0x82, 0x4F, 0x15, 0xBF, 0xFF, 0xBE, 0xF3, 0x52, 0xAE, 0xCD, 0x72, 0xE2, 0x8D, 0x50, 0xB4, 0x95, - 0x71, 0x43, 0x06, 0xDF, 0x95, 0xCC, 0x67, 0xBA, 0x5A, 0x5A, 0xDA, 0x8B, 0x48, 0x25, 0xDC, 0x76, - 0xA0, 0x93, 0xFF, 0x80, 0xCB, 0x74, 0x7B, 0xE3, 0xB7, 0xC3, 0xBE, 0x6B, 0xA2, 0x3C, 0x25, 0xE6, - 0xB6, 0xC5, 0x4E, 0x1B, 0x3F, 0xFE, 0x51, 0xE3, 0x4E, 0x7F, 0x20, 0xC2, 0xC8, 0x72, 0xB3, 0x27, - 0xF1, 0x48, 0xB5, 0x6F, 0x62, 0xFC, 0x39, 0x42, 0x8C, 0x60, 0x5D, 0x55, 0xB5, 0x0A, 0x93, 0x2E, - 0x50, 0x28, 0x60, 0x66, 0x7C, 0x0C, 0x34, 0x12, 0x18, 0x6C, 0x03, 0x9A, 0x54, 0x64, 0x18, 0x00, - 0x35, 0x99, 0x72, 0x4B, 0x99, 0x18, 0x02, 0x98, 0xA6, 0x2C, 0x1E, 0x30, 0x66, 0x28, 0x99, 0xD0, - 0xDC, 0x48, 0x3C, 0x1A, 0x5C, 0xD3, 0xDA, 0x08, 0x2E, 0x61, 0xC8, 0x19, 0x72, 0xEC, 0xB9, 0x35, - 0x55, 0xAD, 0x19, 0xA7, 0x29, 0x6B, 0x63, 0x2A, 0x8B, 0x41, 0xE8, 0x83, 0x1A, 0x6B, 0xCE, 0xDA, - 0xC0, 0x47, 0x29, 0x6D, 0x01, 0x97, 0x3D, 0x6D, 0x8C, 0x39, 0x7B, 0xFB, 0x20, 0xA9, 0x2B, 0x8B, - 0x19, 0x0E, 0x43, 0x84, 0x8C, 0xE3, 0x45, 0x97, 0xE6, 0x44, 0x3C, 0x50, 0xBD, 0x1D, 0x47, 0x86, - 0xA6, 0x3F, 0x2D, 0x96, 0xCF, 0xD1, 0x6C, 0x96, 0x39, 0xF5, 0x0F, 0x1F, 0x37, 0x5C, 0xEB, 0x0B, - 0x1E, 0x14, 0x49, 0x91, 0xEB, 0xBA, 0x17, 0x34, 0x1A, 0xA9, 0x81, 0x7D, 0x5A, 0xCF, 0xBF, 0xBF, - 0x96, 0x63, 0xF2, 0xA1, 0x80, 0xA0, 0x3B, 0xFF, 0xD8, 0xED, 0x15, 0xBF, 0xD4, 0xCA, 0x44, 0xB4, - 0x98, 0xF6, 0x1C, 0x58, 0x2A, 0x41, 0x54, 0x5E, 0x01, 0xA2, 0x8E, 0x63, 0xA3, 0x21, 0xE0, 0xDD, - 0x94, 0x1E, 0xAA, 0xBC, 0xA0, 0xEF, 0xF5, 0x53, 0x72, 0x36, 0xF2, 0x5F, 0x9D, 0x44, 0x26, 0x25, - 0x6D, 0x5F, 0x6B, 0x10, 0x8B, 0x95, 0x9E, 0x00, 0x00, 0x26, 0x20, 0x46, 0x26, 0x11, 0x09, 0xE6, - 0x00, 0x92, 0xC7, 0x2A, 0x0C, 0xE6, 0x17, 0x32, 0x9B, 0x5B, 0xBE, 0x65, 0xD0, 0x19, 0x82, 0xC2, - 0x63, 0xE0, 0xB3, 0x05, 0x80, 0x82, 0x9E, 0x8D, 0x91, 0x63, 0x40, 0xAC, 0xEC, 0x13, 0x2C, 0x01, - 0x6B, 0x84, 0xCD, 0xC2, 0xFF, 0xFB, 0x92, 0x64, 0x17, 0x0F, 0x34, 0x72, 0x34, 0x4C, 0x83, 0xBC, - 0xD1, 0x20, 0x32, 0x46, 0x69, 0x18, 0x09, 0x6A, 0x96, 0x50, 0xA8, 0xCF, 0x34, 0x0E, 0x6B, 0x06, - 0x48, 0xB1, 0x99, 0xA6, 0x14, 0x73, 0x09, 0xEA, 0x82, 0x55, 0x95, 0x4D, 0x99, 0xEA, 0xE1, 0x86, - 0x57, 0xAD, 0xB7, 0xAD, 0xAF, 0x4B, 0xA5, 0xF5, 0xD0, 0x70, 0x30, 0xDA, 0xB8, 0x92, 0x5F, 0x66, - 0x6B, 0x12, 0x10, 0x23, 0x02, 0x11, 0xA9, 0xF4, 0x94, 0x42, 0x23, 0xF1, 0x47, 0xD5, 0xF6, 0x6A, - 0xF0, 0xD8, 0x38, 0x04, 0xA4, 0x18, 0x15, 0x8E, 0x45, 0x55, 0xEE, 0x69, 0x52, 0xE9, 0xED, 0xD7, - 0xA9, 0xFB, 0xAB, 0xCF, 0xFA, 0x5A, 0x09, 0x46, 0x37, 0x70, 0xC2, 0x63, 0x54, 0x38, 0x7D, 0x3D, - 0xEB, 0xB7, 0xBC, 0x94, 0x2D, 0xA5, 0x86, 0x41, 0x33, 0x7C, 0xD8, 0xD3, 0x82, 0x65, 0x25, 0x58, - 0xFF, 0xC7, 0x39, 0xA8, 0xC4, 0x1A, 0x98, 0xF6, 0x80, 0x01, 0x60, 0x00, 0x01, 0x0B, 0xFA, 0x31, - 0x3D, 0x1B, 0x3D, 0xB9, 0x48, 0xD9, 0x34, 0xA1, 0xF5, 0x2E, 0xE8, 0x62, 0x0E, 0xCA, 0xDD, 0x5F, - 0xE2, 0x3D, 0xC4, 0x6A, 0xA2, 0xCD, 0xCC, 0x0D, 0x02, 0xF1, 0xE8, 0xFF, 0xF1, 0xFE, 0xA3, 0xF4, - 0xE7, 0x7D, 0x79, 0xE6, 0x16, 0xCA, 0xA6, 0x87, 0x8C, 0x19, 0xA7, 0x74, 0x12, 0x0C, 0x32, 0xC6, - 0x90, 0x20, 0x3E, 0x62, 0x87, 0xE1, 0xC3, 0x0C, 0xA6, 0x1B, 0x10, 0x1B, 0x0B, 0xF0, 0x77, 0x41, - 0x02, 0x32, 0x9C, 0x92, 0x06, 0x04, 0x09, 0x89, 0x20, 0xF2, 0x25, 0xD8, 0x1F, 0xD0, 0xEB, 0xA4, - 0x4E, 0x79, 0x6A, 0x56, 0x3F, 0x8E, 0x68, 0x9B, 0x6F, 0x37, 0x0C, 0x5E, 0x94, 0x80, 0xC5, 0x0E, - 0x6E, 0x6B, 0x2C, 0x4B, 0xC5, 0x16, 0x53, 0x78, 0x7D, 0xB2, 0xA6, 0xBC, 0xC1, 0x50, 0xEB, 0xFA, - 0x18, 0x47, 0x7A, 0x76, 0xC6, 0xF4, 0xBF, 0x75, 0x87, 0x4C, 0xD9, 0x0A, 0xA3, 0xA7, 0x4F, 0xC5, - 0xB8, 0xC4, 0xEE, 0xE2, 0x88, 0xCC, 0xEA, 0xEC, 0xEC, 0xC5, 0x2E, 0x1F, 0xFF, 0xFD, 0xD4, 0xBB, - 0x0E, 0xE3, 0x41, 0x77, 0xFF, 0xF9, 0x25, 0xBD, 0x57, 0xF2, 0x24, 0x0A, 0x30, 0xBE, 0x82, 0x11, - 0xC8, 0x29, 0x55, 0xA7, 0x8B, 0x08, 0xB8, 0xAE, 0x3F, 0xB6, 0x6A, 0x48, 0x65, 0x2A, 0xAC, 0x20, - 0x42, 0x4B, 0xFD, 0x41, 0x78, 0x63, 0xA9, 0x36, 0xCD, 0x0B, 0xB1, 0x19, 0xFB, 0x2E, 0x0C, 0xE4, - 0xFC, 0x3B, 0x4C, 0x73, 0x23, 0x1F, 0x5B, 0x19, 0xA2, 0x08, 0x19, 0x19, 0x7A, 0x8C, 0xDF, 0xFC, - 0x81, 0x52, 0xA6, 0xDB, 0xFF, 0x08, 0xC7, 0x76, 0xA3, 0x52, 0x0C, 0x3A, 0xAA, 0x19, 0x02, 0x08, - 0x86, 0xE7, 0x8D, 0xF2, 0x96, 0x04, 0x66, 0x0D, 0xD7, 0x1C, 0x7C, 0xF6, 0x00, 0x07, 0x1E, 0x9E, - 0x24, 0x74, 0x03, 0x51, 0x8E, 0x89, 0xC7, 0x81, 0x08, 0x62, 0x82, 0x25, 0xC1, 0x90, 0x18, 0xF8, - 0x30, 0x6B, 0x03, 0xB0, 0x89, 0xC2, 0x55, 0x37, 0x46, 0xF1, 0x76, 0xA8, 0x00, 0x74, 0xAF, 0x83, - 0xB7, 0x79, 0xD0, 0x28, 0x07, 0x01, 0xFF, 0xFB, 0x92, 0x64, 0x1C, 0x8F, 0x34, 0x9A, 0x34, 0xCC, - 0x03, 0x9B, 0xCA, 0x20, 0x2F, 0xC6, 0x09, 0xA8, 0x14, 0x62, 0x7A, 0x51, 0xE8, 0xD1, 0x30, 0x0E, - 0xEF, 0x26, 0xC0, 0xB8, 0x1A, 0x25, 0x94, 0x71, 0x96, 0x22, 0x41, 0xDE, 0xF4, 0xC3, 0x47, 0xB2, - 0x01, 0x80, 0xC7, 0xBB, 0xEC, 0x0C, 0xBD, 0x30, 0xF9, 0x08, 0xEE, 0xE7, 0x56, 0x0D, 0x46, 0x5B, - 0x19, 0xC6, 0x8B, 0x20, 0x11, 0x00, 0x92, 0xE0, 0xC0, 0x4C, 0x31, 0x21, 0xB0, 0xB2, 0xCF, 0x5A, - 0x81, 0x37, 0x47, 0xD5, 0x88, 0xB4, 0x18, 0x25, 0x6F, 0x4E, 0x48, 0x5D, 0x4B, 0xDD, 0xFD, 0x54, - 0xE3, 0xA1, 0x1B, 0xEF, 0xD6, 0xC3, 0xFF, 0xF9, 0x25, 0xBD, 0xFC, 0xBE, 0xD9, 0x45, 0x99, 0x5D, - 0x80, 0xC1, 0xC0, 0xC2, 0x35, 0xD6, 0x0E, 0xCC, 0x11, 0xDA, 0x2D, 0xC6, 0xFA, 0xBD, 0x1A, 0x78, - 0x53, 0x24, 0x5C, 0xEF, 0x40, 0xCC, 0x80, 0x00, 0x0F, 0xFA, 0x00, 0x02, 0xAF, 0xC3, 0xAF, 0x84, - 0x78, 0xC5, 0xEF, 0xB2, 0x55, 0x47, 0x11, 0x81, 0x23, 0x31, 0x74, 0x40, 0xE5, 0x1B, 0x26, 0x06, - 0x3C, 0x40, 0x87, 0xA2, 0xD5, 0xCB, 0xFA, 0xD5, 0xF4, 0x56, 0xFF, 0x42, 0x86, 0x38, 0xA0, 0x6D, - 0x0B, 0xD6, 0x2D, 0x93, 0x7F, 0x0C, 0x01, 0x03, 0x4E, 0x18, 0x5A, 0x03, 0x0A, 0xA1, 0x19, 0xE0, - 0x73, 0x88, 0x42, 0x61, 0xC8, 0x5E, 0x66, 0x26, 0x7A, 0x6A, 0xD3, 0xE6, 0x4A, 0x54, 0x69, 0xCE, - 0xE4, 0xC1, 0x82, 0x15, 0x34, 0x45, 0x30, 0xA4, 0x23, 0x4F, 0x43, 0x53, 0x24, 0x90, 0x07, 0x36, - 0xC2, 0xE5, 0xCF, 0x4A, 0x5A, 0x2B, 0x0B, 0x72, 0x4D, 0x4D, 0xAD, 0x88, 0x16, 0x54, 0x9A, 0x10, - 0xF0, 0x58, 0xF0, 0xE0, 0x89, 0x42, 0x7F, 0x57, 0xC3, 0x4D, 0x16, 0x0A, 0x7C, 0x46, 0xCB, 0x9B, - 0x40, 0x38, 0x54, 0x58, 0xC3, 0x7C, 0x4F, 0x27, 0x84, 0x21, 0xB5, 0xAF, 0x7C, 0x8A, 0xD8, 0xA1, - 0x0B, 0x03, 0x47, 0x2C, 0x0A, 0xCB, 0x8C, 0xB2, 0xBB, 0x54, 0x09, 0x83, 0x7B, 0xB0, 0x98, 0x86, - 0xB9, 0xF5, 0x78, 0xEF, 0xBE, 0x7D, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xD4, 0x6C, 0x61, 0xAC, - 0x80, 0x28, 0x01, 0x6D, 0x4B, 0x96, 0xCA, 0x12, 0xFD, 0x99, 0x3F, 0x17, 0xEB, 0x56, 0xC1, 0xB5, - 0xBC, 0x99, 0x97, 0xC1, 0x05, 0xBE, 0x80, 0x0C, 0x59, 0xF4, 0x07, 0xCF, 0x8D, 0x8E, 0x50, 0xAC, - 0x20, 0xEE, 0xC2, 0xD0, 0x65, 0xFA, 0x53, 0xFD, 0xAF, 0x56, 0x01, 0x55, 0xC2, 0xA8, 0x9F, 0x0E, - 0x89, 0xA1, 0xB2, 0xB7, 0xD4, 0xD0, 0x75, 0xFF, 0xFE, 0x62, 0x16, 0xDE, 0xB0, 0x18, 0x71, 0x44, - 0x45, 0xAA, 0x5B, 0xE1, 0x60, 0xC4, 0xE5, 0xD0, 0x7C, 0x58, 0x65, 0x31, 0xBC, 0x83, 0x39, 0x94, - 0x14, 0x30, 0xCC, 0x34, 0x34, 0x02, 0x2E, 0x3D, 0xD3, 0x03, 0x04, 0x46, 0x38, 0xF6, 0x50, 0x52, - 0xD1, 0x90, 0x30, 0x19, 0x78, 0x49, 0x8D, 0x99, 0x9C, 0xAA, 0x12, 0xC7, 0x31, 0x30, 0xB5, 0x02, - 0x55, 0x37, 0x32, 0xCA, 0xD8, 0x52, 0xC8, 0xD3, 0xFF, 0xFB, 0x92, 0x64, 0x1B, 0x0F, 0xB4, 0x87, - 0x34, 0x4C, 0x03, 0xBB, 0xC9, 0xB0, 0x32, 0xA6, 0x89, 0x25, 0x05, 0x87, 0x74, 0x11, 0xD8, 0xD3, - 0x30, 0x0E, 0xF3, 0x42, 0xC0, 0xC3, 0x97, 0xE4, 0xC0, 0x90, 0x1C, 0x30, 0x7F, 0x69, 0x3B, 0x93, - 0x8F, 0x05, 0x4D, 0x0C, 0x2E, 0xF7, 0x61, 0x7D, 0x11, 0x08, 0xCA, 0x57, 0x92, 0x70, 0xBE, 0xC2, - 0x08, 0xD1, 0x1D, 0x59, 0x00, 0x08, 0xB5, 0x83, 0x02, 0x91, 0x75, 0xE7, 0x41, 0x46, 0x34, 0x75, - 0x2F, 0x1E, 0x83, 0x60, 0xDA, 0x5B, 0x03, 0x52, 0x86, 0x1D, 0x74, 0x3F, 0x81, 0xDF, 0x42, 0xFD, - 0xCB, 0xAF, 0xD7, 0x75, 0xA8, 0xBF, 0x52, 0x7F, 0x7D, 0x25, 0x5C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFD, 0xAB, 0x73, 0xC9, 0x04, 0x84, 0x55, 0x0C, 0x24, 0x6B, 0x45, 0x60, 0xA5, 0xB5, 0x6A, 0xDF, - 0xAA, 0xCC, 0x26, 0xD4, 0x15, 0x3B, 0x46, 0x08, 0x80, 0x03, 0x7F, 0xAA, 0xFF, 0x2C, 0x50, 0xF9, - 0x62, 0x91, 0x34, 0x44, 0x58, 0x8E, 0xE7, 0x7E, 0x61, 0xA2, 0x5E, 0x38, 0x34, 0x21, 0x5F, 0xFE, - 0x95, 0x61, 0xA3, 0x8F, 0xB8, 0xD4, 0x5F, 0xF9, 0x50, 0x7C, 0x44, 0xAF, 0xFF, 0xD0, 0xB5, 0x44, - 0x76, 0x76, 0x08, 0x01, 0xC3, 0x68, 0x60, 0x66, 0x71, 0x16, 0x7E, 0x4A, 0x0F, 0x9C, 0x88, 0x8F, - 0x8D, 0x18, 0x43, 0x17, 0xF3, 0xDD, 0x8C, 0x8C, 0x32, 0x07, 0x39, 0xBA, 0x98, 0xD1, 0x06, 0x43, - 0x36, 0x1A, 0xCD, 0x2A, 0x66, 0x11, 0x82, 0xCD, 0xA9, 0x63, 0x04, 0x78, 0xDB, 0xCD, 0x33, 0xC8, - 0x51, 0xD8, 0x69, 0xAB, 0x4D, 0xBB, 0x25, 0xDB, 0xE0, 0xA1, 0x32, 0x99, 0x6E, 0x4F, 0x40, 0xF1, - 0x3B, 0xA8, 0xBF, 0x29, 0x51, 0x51, 0xE6, 0x0F, 0x02, 0x88, 0x5E, 0x6C, 0x4C, 0xDE, 0x7C, 0x50, - 0x29, 0x59, 0x34, 0xDB, 0x33, 0x23, 0x17, 0xA8, 0xE1, 0x52, 0x71, 0xD1, 0x80, 0xE1, 0xCD, 0xAC, - 0xE8, 0x93, 0xD4, 0x9C, 0x32, 0x00, 0x10, 0x56, 0x60, 0xBB, 0x0A, 0x2F, 0x06, 0x36, 0xF8, 0x13, - 0x16, 0x85, 0xBA, 0xB2, 0x19, 0x65, 0x9F, 0xD4, 0x9F, 0xEE, 0xD9, 0xE7, 0xFF, 0xFF, 0xFF, 0xEF, - 0xBF, 0xFE, 0xB0, 0x8A, 0x11, 0x00, 0x84, 0x30, 0x7E, 0x52, 0x95, 0xB6, 0x76, 0x98, 0x73, 0xCB, - 0xFB, 0xAB, 0x00, 0x4B, 0xE9, 0xDE, 0x69, 0x57, 0x02, 0xCF, 0xBB, 0x28, 0xD8, 0x74, 0xC2, 0x2C, - 0x24, 0x8B, 0xC5, 0xE2, 0x88, 0x39, 0x12, 0x9E, 0x50, 0x60, 0xF2, 0xA1, 0xFF, 0xFF, 0x12, 0xC0, - 0x69, 0x10, 0x78, 0x2C, 0x24, 0x2A, 0x07, 0xDB, 0xBB, 0xD4, 0xD6, 0x3B, 0xFF, 0xE8, 0x25, 0x83, - 0x09, 0x8A, 0x14, 0x15, 0x1A, 0x86, 0x84, 0xFB, 0x4A, 0xD5, 0x00, 0x80, 0x03, 0x0F, 0x30, 0x08, - 0x03, 0x39, 0xEE, 0x46, 0x30, 0x58, 0x02, 0x30, 0xA6, 0x1F, 0x32, 0x44, 0x56, 0x00, 0x8F, 0xE6, - 0x04, 0x4A, 0xA6, 0xCE, 0x12, 0x61, 0xCD, 0x27, 0x74, 0x98, 0x0A, 0x31, 0x32, 0xF7, 0x70, 0x34, - 0xE9, 0x86, 0xA5, 0x89, 0xBD, 0x8A, 0x80, 0x04, 0x1F, 0x34, 0xFF, 0xFB, 0x92, 0x64, 0x18, 0x0B, - 0x34, 0xAC, 0x34, 0x4B, 0xAB, 0xBB, 0xD1, 0xB0, 0x2F, 0x26, 0x69, 0x25, 0x00, 0xC7, 0x76, 0x92, - 0xC8, 0xD3, 0x2E, 0x0E, 0xF3, 0x44, 0x80, 0xBE, 0x19, 0xE5, 0xA0, 0x61, 0x96, 0x2A, 0x8E, 0xE1, - 0x2D, 0xA8, 0xAB, 0x5C, 0x07, 0xD7, 0x38, 0xF0, 0xF1, 0xA9, 0xE5, 0xBA, 0xDB, 0x8A, 0x0A, 0x43, - 0xD8, 0x28, 0x48, 0x05, 0x33, 0xB6, 0x56, 0x2D, 0x60, 0xD0, 0xF4, 0x6A, 0xDA, 0xC4, 0x38, 0xC1, - 0xDD, 0x94, 0x1C, 0x28, 0xEC, 0xC1, 0xD2, 0x15, 0x86, 0x0A, 0x38, 0x60, 0x0D, 0xB1, 0x83, 0x3C, - 0xA0, 0xCC, 0xF0, 0xB4, 0x64, 0x80, 0xC3, 0x81, 0x37, 0x0A, 0x66, 0x75, 0x23, 0x63, 0x11, 0x99, - 0x35, 0xCF, 0xBB, 0x4D, 0xB9, 0x8B, 0xDF, 0xDF, 0xFD, 0x61, 0x87, 0xC9, 0x2F, 0xFF, 0xD8, 0x5D, - 0x48, 0x1B, 0x40, 0x50, 0x8E, 0xC1, 0x54, 0x0D, 0x25, 0xA4, 0xD3, 0x90, 0xFE, 0xF5, 0x0A, 0xC1, - 0xF7, 0x54, 0x52, 0x90, 0x08, 0x00, 0x73, 0x4B, 0x2C, 0x18, 0x25, 0x5E, 0x42, 0x89, 0x26, 0x47, - 0x1D, 0x5C, 0xF1, 0x84, 0xC9, 0x0A, 0x46, 0x7F, 0xFD, 0x4F, 0x22, 0x40, 0xB0, 0xD8, 0xEB, 0x31, - 0xE2, 0x70, 0xEB, 0xEA, 0x6D, 0xFF, 0xFC, 0xE1, 0x71, 0xC6, 0x97, 0x34, 0x74, 0x49, 0x17, 0x79, - 0xE3, 0xE2, 0x5A, 0x95, 0x18, 0x06, 0x15, 0x9C, 0x11, 0xB2, 0x8D, 0x1B, 0x66, 0x08, 0x45, 0x26, - 0x5C, 0x0E, 0xC6, 0x05, 0x05, 0x1D, 0x6B, 0x40, 0x11, 0x5F, 0x0C, 0x38, 0x9C, 0xF0, 0x8A, 0x60, - 0x20, 0x28, 0xEC, 0x50, 0xD6, 0xE4, 0x36, 0x4F, 0x13, 0x65, 0x18, 0x34, 0x42, 0xD7, 0x7C, 0x2A, - 0x05, 0xBD, 0x02, 0x27, 0xC3, 0xA2, 0xC1, 0xBE, 0x26, 0x50, 0x2E, 0x69, 0x10, 0xA9, 0x16, 0x31, - 0x12, 0xB8, 0xDA, 0x36, 0xBB, 0x04, 0xA0, 0x5B, 0x82, 0x8A, 0x1A, 0xE8, 0x46, 0x34, 0x50, 0xA0, - 0x83, 0xC6, 0x1D, 0x77, 0x15, 0x11, 0x07, 0x1A, 0x6A, 0x60, 0xD2, 0x10, 0x00, 0x25, 0x42, 0x96, - 0xB7, 0xA6, 0x29, 0x2B, 0x61, 0x5F, 0x25, 0x01, 0xDE, 0x34, 0x80, 0x70, 0xE0, 0xD5, 0x18, 0x9D, - 0x19, 0x00, 0xCD, 0x26, 0xA0, 0xB9, 0xFD, 0xE3, 0xF9, 0x72, 0x82, 0x7F, 0xFF, 0x09, 0x24, 0x87, - 0x09, 0x25, 0xCC, 0x75, 0xD2, 0xA0, 0x38, 0xCA, 0xDB, 0x2D, 0xB5, 0x55, 0x0D, 0xA3, 0xC1, 0x81, - 0x6B, 0x5F, 0xD7, 0xE6, 0xFA, 0x81, 0xC3, 0x55, 0xBA, 0x08, 0x01, 0x03, 0xDF, 0xFF, 0x4C, 0x08, - 0x8B, 0xDF, 0xCC, 0x08, 0xC7, 0xB8, 0xE4, 0x07, 0x0C, 0x4F, 0xC7, 0x3F, 0xF0, 0x89, 0x45, 0xD1, - 0x60, 0xC5, 0x9C, 0x85, 0xD7, 0x7F, 0xD1, 0x3C, 0x10, 0xFE, 0x60, 0xC7, 0x77, 0x27, 0xFF, 0xCF, - 0xB7, 0xAB, 0xA6, 0xD9, 0xBE, 0x20, 0x2A, 0x80, 0xCA, 0x42, 0x68, 0x50, 0x4C, 0x33, 0x4F, 0x04, - 0x30, 0x5C, 0x20, 0x2A, 0x36, 0x27, 0x16, 0x0C, 0x86, 0x04, 0x00, 0x46, 0x97, 0x9F, 0xC6, 0x50, - 0x34, 0x64, 0x2A, 0xC6, 0x44, 0x3E, 0x62, 0x60, 0x26, 0x38, 0xA8, 0x61, 0xFF, 0xFB, 0x92, 0x64, - 0x11, 0x8A, 0x04, 0xA7, 0x34, 0x4C, 0x03, 0xBB, 0xD1, 0xB0, 0x33, 0x25, 0x09, 0xFA, 0x14, 0xC5, - 0x76, 0x90, 0xEC, 0xCF, 0x36, 0xEE, 0xF3, 0x42, 0x40, 0xCB, 0x0D, 0xA7, 0xB4, 0x53, 0x0D, 0xC0, - 0xA1, 0x80, 0x20, 0x63, 0xA8, 0x0D, 0x45, 0x00, 0x28, 0xE3, 0x8F, 0x30, 0xDB, 0x5E, 0x6E, 0x04, - 0xC0, 0x1B, 0xE6, 0x58, 0xF9, 0x3D, 0x68, 0x5D, 0xC7, 0x4D, 0xD9, 0x46, 0x71, 0x21, 0x53, 0xEB, - 0x07, 0x09, 0x6E, 0x24, 0x46, 0x14, 0x50, 0xCC, 0x9C, 0x2B, 0x24, 0x17, 0x2C, 0x76, 0x46, 0x3F, - 0xA2, 0x11, 0x12, 0xEC, 0x8B, 0x72, 0xBD, 0x8B, 0x24, 0x84, 0x2D, 0x50, 0x1A, 0x41, 0xCE, 0x14, - 0x18, 0x1C, 0xCD, 0xF3, 0x53, 0x37, 0x62, 0xBA, 0xCD, 0xA8, 0x23, 0x07, 0x5F, 0x36, 0x85, 0x47, - 0xFF, 0xAF, 0xF9, 0x24, 0x9F, 0x3D, 0x72, 0x82, 0x93, 0x0B, 0xB1, 0xBA, 0xEE, 0xD4, 0xB5, 0x7C, - 0xBB, 0xED, 0xD5, 0x86, 0xE4, 0xB0, 0x2C, 0x7F, 0x4D, 0xD7, 0x7A, 0x99, 0xEC, 0x35, 0xC7, 0x91, - 0x6B, 0xE2, 0x00, 0x45, 0x48, 0x00, 0x30, 0x20, 0x07, 0xF8, 0xC5, 0x82, 0x3E, 0x30, 0xB5, 0x24, - 0xA6, 0x23, 0x29, 0x67, 0x4E, 0x46, 0xF8, 0xE7, 0xA6, 0xFA, 0xCD, 0x92, 0x82, 0x8D, 0xA9, 0x88, - 0xA7, 0x73, 0xD5, 0xDD, 0x59, 0x74, 0xE4, 0x6E, 0x85, 0x6A, 0x02, 0x00, 0xC2, 0x47, 0x77, 0x27, - 0xF7, 0xFF, 0xDF, 0xFE, 0x18, 0x20, 0x18, 0x06, 0xC4, 0x3A, 0x0A, 0x99, 0x07, 0x0D, 0x98, 0x22, - 0x06, 0x98, 0xF0, 0x82, 0x7E, 0x41, 0xD1, 0x86, 0x84, 0xA6, 0x06, 0x82, 0x99, 0x00, 0xA6, 0x40, - 0x40, 0x68, 0x76, 0xCA, 0x4B, 0x38, 0xB4, 0x20, 0xD0, 0xE7, 0x20, 0xAC, 0x3E, 0x60, 0x43, 0xBB, - 0x4D, 0x21, 0xA7, 0x55, 0x61, 0x0A, 0xF6, 0x21, 0x07, 0xB7, 0xB1, 0x98, 0x5F, 0x64, 0x14, 0xAC, - 0x45, 0x5B, 0x2C, 0xAC, 0x03, 0x40, 0x98, 0x78, 0x66, 0x54, 0x48, 0x79, 0xA3, 0x20, 0x55, 0xB5, - 0x58, 0xD4, 0xAE, 0x61, 0xD0, 0x89, 0xA9, 0x90, 0x40, 0x78, 0x92, 0x5B, 0xB3, 0x66, 0x96, 0x5B, - 0xE8, 0xBB, 0x29, 0x6B, 0xF5, 0xA6, 0x7D, 0xBA, 0xE5, 0xD8, 0x76, 0xFF, 0xFE, 0xB7, 0x6F, 0x2B, - 0x7F, 0xF5, 0x7F, 0x2E, 0x50, 0xE1, 0x7D, 0xE1, 0xBD, 0x42, 0xFF, 0x50, 0xC7, 0xAD, 0xCF, 0x50, - 0x6A, 0xE5, 0xAF, 0x95, 0x58, 0xC6, 0x4D, 0x4B, 0x4A, 0x1C, 0xFF, 0xC3, 0x84, 0x70, 0x30, 0x09, - 0x00, 0x00, 0x20, 0x70, 0x06, 0xFB, 0x20, 0x6A, 0x9D, 0x9E, 0x81, 0xB8, 0x5D, 0xA0, 0x17, 0xCA, - 0x10, 0x43, 0xB3, 0x85, 0x1A, 0x86, 0x00, 0x72, 0xCC, 0x81, 0xB0, 0xD9, 0xC3, 0x02, 0xA4, 0xE2, - 0x96, 0x70, 0x92, 0xEE, 0x7E, 0x9A, 0xD5, 0xB8, 0xB2, 0xBE, 0xAF, 0xF8, 0xA2, 0xAD, 0xF6, 0xD5, - 0x44, 0x13, 0x03, 0xC3, 0x03, 0x63, 0x29, 0x63, 0x0C, 0xC1, 0xC1, 0x11, 0x7C, 0x70, 0x90, 0xFA, - 0x0C, 0x0D, 0x07, 0x88, 0x9B, 0x68, 0x29, 0x83, 0x11, 0x98, 0x00, 0x62, 0x8D, 0x00, 0xFF, 0xFB, - 0x92, 0x64, 0x0F, 0x0F, 0xF4, 0x6A, 0x34, 0xCC, 0x83, 0xBB, 0xC1, 0x40, 0x2E, 0xE3, 0xD9, 0xA8, - 0x04, 0xA3, 0x68, 0x12, 0x88, 0xD3, 0x2E, 0x0E, 0xEF, 0x26, 0xC0, 0xBD, 0x17, 0xE5, 0x00, 0x20, - 0x20, 0x28, 0x4C, 0x89, 0x89, 0x0C, 0x38, 0x68, 0xE1, 0x10, 0x9A, 0x61, 0x88, 0x0B, 0xAA, 0x16, - 0x10, 0xDF, 0x6D, 0x37, 0x97, 0xBC, 0x06, 0xBE, 0x5F, 0xB5, 0x87, 0x5D, 0x94, 0xCC, 0x68, 0xBA, - 0xEC, 0x15, 0x0F, 0xD8, 0x1A, 0x65, 0x24, 0x83, 0xF8, 0x10, 0x47, 0xE5, 0x06, 0x01, 0x07, 0x4E, - 0x80, 0xBC, 0x98, 0x24, 0xF3, 0x06, 0xB2, 0x8D, 0xC9, 0x50, 0x3C, 0x51, 0x12, 0xA3, 0x85, 0xE5, - 0xA7, 0x80, 0xC1, 0x8B, 0x4F, 0x38, 0xD3, 0x70, 0x95, 0xBA, 0x14, 0xF0, 0x4A, 0xA0, 0x94, 0x43, - 0x55, 0xAF, 0x7E, 0xB7, 0x4D, 0xF3, 0x7A, 0xD4, 0xF7, 0x66, 0x77, 0xF4, 0xB6, 0xAF, 0xC8, 0xF1, - 0xFB, 0x71, 0x29, 0x44, 0xA1, 0xB1, 0xE7, 0x6B, 0xF7, 0x4A, 0xF2, 0xF5, 0x94, 0xCE, 0x47, 0x97, - 0x5F, 0x0F, 0x0D, 0x00, 0x00, 0x01, 0x59, 0x09, 0x85, 0x9E, 0x27, 0x50, 0x96, 0x93, 0x32, 0xA5, - 0x84, 0xF4, 0x60, 0x54, 0x0E, 0xA8, 0x32, 0xD7, 0xAB, 0xA3, 0xBB, 0x0E, 0x75, 0xA4, 0xD7, 0x0E, - 0x08, 0x9A, 0x21, 0x4A, 0x56, 0x9A, 0x92, 0xCC, 0xD8, 0x22, 0x70, 0x68, 0x96, 0x44, 0xB1, 0x64, - 0x83, 0x81, 0xA1, 0x21, 0x60, 0xEB, 0x78, 0x8C, 0xC6, 0x60, 0xD4, 0xC0, 0x77, 0x00, 0xDB, 0xB4, - 0x54, 0x48, 0x14, 0x31, 0x5E, 0x04, 0x08, 0x8C, 0x35, 0x42, 0x83, 0xB2, 0x0D, 0x48, 0xC4, 0x13, - 0x8D, 0x16, 0x01, 0x5B, 0x0C, 0x11, 0xFE, 0x64, 0x04, 0x9C, 0x24, 0x8A, 0x04, 0x12, 0x3A, 0x99, - 0x6D, 0x87, 0x04, 0xCC, 0xC6, 0x81, 0x50, 0xA5, 0xD0, 0x16, 0x1D, 0xCA, 0x46, 0xD5, 0x5C, 0x5B, - 0xA0, 0x68, 0xCC, 0xE5, 0x2F, 0x45, 0x0D, 0x74, 0x99, 0x83, 0x9B, 0x36, 0x1E, 0xF4, 0x7C, 0x2A, - 0x82, 0x14, 0xCD, 0xA4, 0xFC, 0x4C, 0x50, 0x82, 0xEA, 0xB3, 0x03, 0x14, 0x95, 0x98, 0x0E, 0x0A, - 0x08, 0x7D, 0x10, 0x90, 0x4D, 0x1D, 0xE4, 0x19, 0x7F, 0xD3, 0xDA, 0x92, 0xF3, 0x0F, 0x93, 0x5F, - 0x58, 0xF7, 0xFF, 0xF5, 0x31, 0xCB, 0x32, 0xFD, 0xD1, 0x73, 0x52, 0xCE, 0xC1, 0x54, 0x74, 0x32, - 0x0B, 0x3A, 0x51, 0x9F, 0x4B, 0xD9, 0x14, 0x89, 0xF8, 0xDE, 0xB1, 0x94, 0xB6, 0x7A, 0x68, 0xC3, - 0x53, 0x78, 0x19, 0xC6, 0x61, 0xB8, 0xD1, 0x5B, 0xF1, 0xA0, 0xAE, 0x55, 0x50, 0xA3, 0xBD, 0x87, - 0x8C, 0x38, 0xE8, 0x18, 0x10, 0x45, 0xFE, 0xDB, 0x43, 0x1D, 0xCD, 0x14, 0x6E, 0xB2, 0xB4, 0x7A, - 0xF1, 0x78, 0xB5, 0xFF, 0x9B, 0xFC, 0x35, 0x9A, 0xDF, 0x8D, 0x16, 0xB1, 0x71, 0x11, 0x16, 0xB1, - 0x5B, 0xC5, 0x20, 0xD2, 0x55, 0x03, 0x0A, 0xC0, 0xE3, 0x84, 0x07, 0xD2, 0x63, 0x1C, 0x44, 0x1F, - 0x1E, 0x4A, 0x08, 0x06, 0x09, 0x13, 0x28, 0x1F, 0x02, 0xD1, 0x89, 0x20, 0x07, 0x67, 0x85, 0xC4, - 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0xF4, 0x6A, 0x34, 0xCC, 0x83, 0xBB, 0xC9, 0x30, 0x31, 0x65, - 0xF8, 0xD0, 0x00, 0x2D, 0x60, 0x11, 0xBC, 0xD5, 0x32, 0x0E, 0xEB, 0x06, 0x40, 0xC5, 0x16, 0xE3, - 0x40, 0x03, 0x34, 0x91, 0x4C, 0x74, 0x5C, 0xC2, 0x8A, 0x44, 0x69, 0xC6, 0xBA, 0x88, 0x1E, 0x67, - 0x1C, 0xAF, 0xD9, 0x92, 0x15, 0x58, 0x70, 0x15, 0x82, 0x53, 0x82, 0x59, 0x68, 0x46, 0x23, 0xA4, - 0xDD, 0x54, 0x9C, 0xC2, 0xCF, 0x48, 0xC5, 0xAC, 0x18, 0x33, 0x64, 0x4A, 0xE6, 0xAC, 0xCC, 0xC1, - 0x5E, 0xBA, 0xE4, 0x81, 0x21, 0x5D, 0x3B, 0x18, 0x9C, 0x55, 0x61, 0xB2, 0x92, 0xAC, 0xB0, 0xAB, - 0x6E, 0x8F, 0xAA, 0xFD, 0xDF, 0x5C, 0xC5, 0x62, 0xE8, 0x64, 0x88, 0xEC, 0x3C, 0x81, 0x3A, 0xEF, - 0x8D, 0x1D, 0x0B, 0xB1, 0xFF, 0xFF, 0x25, 0xE6, 0x3A, 0xED, 0x06, 0x56, 0x65, 0x7F, 0x41, 0xAD, - 0xB3, 0xFD, 0x49, 0x5A, 0x9D, 0x3B, 0xFA, 0xDF, 0x54, 0x73, 0x6F, 0x4F, 0xE3, 0xB8, 0xE5, 0xAA, - 0x66, 0xF9, 0xE8, 0x62, 0x76, 0x26, 0x1E, 0x21, 0xC5, 0x43, 0xF5, 0x07, 0x67, 0x4B, 0x44, 0x39, - 0x26, 0x87, 0xE6, 0x02, 0x18, 0x2A, 0x77, 0xFD, 0x4F, 0xEA, 0xF4, 0x54, 0x3B, 0x41, 0x3B, 0x12, - 0xB6, 0x40, 0x7D, 0x33, 0x5F, 0x58, 0xD4, 0x2B, 0xBD, 0x54, 0x94, 0xFC, 0x9A, 0x4A, 0x98, 0x97, - 0x48, 0x85, 0x8A, 0x52, 0x89, 0x62, 0x93, 0x3F, 0x30, 0x40, 0x28, 0x37, 0x9E, 0x3E, 0x32, 0x18, - 0x38, 0x32, 0x35, 0xAF, 0x36, 0x64, 0xC4, 0x31, 0x1C, 0x17, 0x32, 0x35, 0xA5, 0x34, 0x89, 0xCD, - 0x02, 0x53, 0x75, 0x38, 0xA0, 0xAA, 0x44, 0x18, 0x28, 0x08, 0x40, 0xAE, 0xA5, 0x20, 0x1D, 0x29, - 0x73, 0xD4, 0xE4, 0x43, 0xAF, 0xB3, 0x71, 0xDA, 0xA8, 0x31, 0xF9, 0x92, 0xE7, 0xD0, 0x2A, 0x75, - 0xE0, 0xBB, 0x0A, 0xAF, 0x5F, 0x4D, 0x61, 0x93, 0xBC, 0x49, 0x8E, 0xF6, 0xA8, 0xD8, 0x1A, 0xD2, - 0x32, 0x09, 0x02, 0xD7, 0x06, 0xAA, 0x39, 0x6A, 0xFB, 0x00, 0x89, 0x5F, 0xAD, 0x15, 0x11, 0x5C, - 0xC1, 0xC0, 0x86, 0x9F, 0x72, 0x25, 0x4C, 0x8C, 0x9D, 0xF4, 0x91, 0x0F, 0x2E, 0xEA, 0xF0, 0xCB, - 0x1E, 0xDE, 0xFF, 0xC6, 0x96, 0xFD, 0x78, 0xA6, 0x9F, 0x4E, 0xD7, 0xA6, 0xE4, 0x73, 0xFD, 0xD0, - 0xBE, 0xC2, 0xE4, 0x54, 0x2E, 0x54, 0x22, 0x38, 0xE3, 0xEA, 0x33, 0x6F, 0xE0, 0x9C, 0x64, 0xB1, - 0x67, 0x7E, 0x3F, 0x3F, 0xCF, 0x12, 0x10, 0xFA, 0x87, 0xF8, 0xC5, 0x13, 0x14, 0x37, 0x7A, 0x96, - 0xEE, 0x4D, 0x19, 0x62, 0x78, 0x03, 0x20, 0x58, 0x13, 0x92, 0x44, 0xDD, 0x4C, 0xF5, 0x7F, 0xFA, - 0x93, 0x0F, 0x00, 0xCC, 0x80, 0xB5, 0x66, 0x5E, 0xB3, 0x01, 0xBC, 0xFA, 0x92, 0x3A, 0x30, 0x6F, - 0xFE, 0xB2, 0xE9, 0xA2, 0x5D, 0x9A, 0x63, 0x43, 0x81, 0xA9, 0xA9, 0x17, 0xF9, 0x81, 0x80, 0x79, - 0x8B, 0x8D, 0x69, 0xC1, 0xC7, 0xA1, 0x83, 0x82, 0x09, 0xA0, 0x01, 0xB8, 0xF2, 0x86, 0xCB, 0x4C, - 0x2C, 0x1C, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x74, 0x6E, 0x34, 0xCC, 0x83, 0xBA, 0x7A, 0xF0, - 0x32, 0x66, 0x59, 0x65, 0x1D, 0x22, 0x94, 0xD1, 0x48, 0xD3, 0x34, 0x0E, 0xE9, 0xEB, 0xC0, 0xB5, - 0x17, 0xE6, 0xA0, 0xA3, 0x0A, 0x18, 0x44, 0x81, 0x61, 0x1A, 0xD3, 0x20, 0x1C, 0x0C, 0x58, 0xE0, - 0x29, 0x90, 0x2B, 0x32, 0xB4, 0x2E, 0x68, 0x06, 0x92, 0x5E, 0x44, 0x1D, 0xDB, 0x7E, 0xAB, 0x3B, - 0xE5, 0xC8, 0xC0, 0x60, 0x0B, 0x51, 0x4C, 0x72, 0xF2, 0x2E, 0x64, 0x8A, 0x0C, 0x19, 0x52, 0x01, - 0x89, 0xBF, 0xA0, 0x28, 0xB2, 0xB2, 0x13, 0x45, 0x69, 0xD7, 0x8A, 0x18, 0xF5, 0xFD, 0x1E, 0x08, - 0x48, 0x10, 0x40, 0x52, 0x79, 0x64, 0xAA, 0x99, 0x71, 0x18, 0x00, 0x8B, 0xA8, 0x0A, 0x03, 0xD8, - 0x2F, 0xC7, 0x92, 0xB0, 0x81, 0x34, 0x2E, 0xDA, 0x7F, 0xF5, 0x85, 0x35, 0x1A, 0x34, 0xB7, 0x35, - 0x19, 0x74, 0xDD, 0x56, 0xA3, 0x96, 0x84, 0x6E, 0x96, 0x31, 0x99, 0xD4, 0xE8, 0x75, 0x97, 0xB7, - 0x94, 0xF6, 0x8F, 0x76, 0x97, 0x82, 0x69, 0x18, 0x40, 0x00, 0x0A, 0xFF, 0x40, 0x26, 0x05, 0x1A, - 0x7F, 0xEB, 0xDC, 0xF7, 0xF6, 0xDC, 0xEE, 0xBF, 0x12, 0x9C, 0x6F, 0x6B, 0x01, 0x71, 0x39, 0x39, - 0x1B, 0x6A, 0x8C, 0x85, 0x7D, 0x12, 0x1C, 0xEE, 0x1D, 0xC3, 0x0E, 0x8D, 0x41, 0x1D, 0x09, 0x25, - 0x4D, 0xFA, 0xEA, 0x75, 0x00, 0x60, 0xE3, 0xFE, 0x11, 0xD3, 0x92, 0x81, 0x26, 0x03, 0x87, 0xC6, - 0x40, 0x57, 0x06, 0x13, 0x04, 0xC1, 0x84, 0x01, 0xD7, 0x00, 0xD8, 0xD0, 0xE8, 0x64, 0xCA, 0x34, - 0xA6, 0x21, 0xC1, 0xC1, 0x8E, 0xA1, 0x10, 0x18, 0x23, 0x02, 0x1B, 0x00, 0x89, 0x2C, 0x31, 0x23, - 0xD4, 0x98, 0x41, 0x40, 0x64, 0x45, 0x17, 0x4C, 0x6A, 0xB3, 0xD2, 0xA6, 0x10, 0x4A, 0xD0, 0x96, - 0x43, 0x85, 0xCB, 0xC9, 0xEB, 0x4D, 0x47, 0x5C, 0xBF, 0x4D, 0x01, 0x97, 0xA3, 0xEB, 0x86, 0xAC, - 0x0A, 0xD7, 0x04, 0x09, 0x37, 0x62, 0xE5, 0x80, 0x85, 0x18, 0x99, 0xF9, 0x7B, 0xA9, 0x53, 0xF0, - 0x69, 0x6C, 0x0A, 0x4A, 0x21, 0x70, 0xC3, 0x84, 0x40, 0x90, 0xE1, 0x90, 0x35, 0xAA, 0x0B, 0x37, - 0x20, 0x49, 0x93, 0x49, 0x4C, 0x3A, 0xA6, 0x71, 0xFE, 0x32, 0xC3, 0x34, 0x91, 0x73, 0x17, 0xC9, - 0xAE, 0xFF, 0xE0, 0xD2, 0xE1, 0x4F, 0x9B, 0x20, 0x39, 0xF2, 0x81, 0xDC, 0x1D, 0x61, 0x19, 0xB4, - 0x8A, 0x5F, 0x44, 0xBE, 0x80, 0x60, 0x6B, 0xFD, 0x04, 0x00, 0x66, 0x5C, 0x4B, 0x2F, 0xFD, 0xF3, - 0x1E, 0x3F, 0x9A, 0x63, 0x90, 0x6A, 0x6B, 0xB8, 0x44, 0x4B, 0x87, 0x10, 0x78, 0x34, 0x06, 0xE2, - 0xBC, 0xB2, 0x92, 0x8E, 0x84, 0x54, 0x64, 0x3F, 0x45, 0xF6, 0xFB, 0x70, 0x63, 0xDD, 0xA3, 0xF4, - 0x34, 0xCD, 0x2F, 0x31, 0x82, 0xC2, 0x19, 0xC3, 0x79, 0x19, 0x87, 0xC2, 0x28, 0x15, 0xFC, 0x34, - 0xD8, 0xF7, 0x14, 0x24, 0x33, 0x1D, 0xE3, 0xD4, 0x54, 0x31, 0xC1, 0x43, 0x68, 0x5A, 0x02, 0x0B, - 0x85, 0x5C, 0x57, 0x60, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x14, 0x8F, 0x34, 0xCC, 0x03, 0xBB, - 0xC9, 0x30, 0x2E, 0xC3, 0xC9, 0xB8, 0x1C, 0x43, 0x4A, 0x11, 0x9C, 0xD3, 0x32, 0x0E, 0xEB, 0x26, - 0x80, 0xC3, 0x17, 0x66, 0x60, 0x23, 0x0B, 0x02, 0x5A, 0x3C, 0x14, 0xA2, 0x11, 0x05, 0xDA, 0x16, - 0xE1, 0xAF, 0x45, 0x68, 0xA2, 0x88, 0xFB, 0x4A, 0xAD, 0xB0, 0x73, 0x5A, 0x2A, 0x05, 0x7D, 0xFD, - 0x12, 0x15, 0x82, 0x08, 0x15, 0x81, 0xD0, 0xCD, 0x63, 0xAF, 0x15, 0xF1, 0x22, 0x6E, 0xA6, 0x41, - 0x95, 0xC8, 0x3A, 0x1B, 0x9D, 0x3B, 0x51, 0x95, 0xD5, 0x18, 0x70, 0x38, 0xC4, 0x99, 0x24, 0x95, - 0x2F, 0x44, 0x60, 0x04, 0x08, 0xD7, 0x09, 0x10, 0x8B, 0x60, 0x14, 0x12, 0x7C, 0x80, 0x51, 0xA1, - 0x63, 0x8B, 0xA6, 0x45, 0x11, 0x84, 0xFF, 0xFE, 0xF3, 0x94, 0xD0, 0x4E, 0x7D, 0x37, 0xE5, 0x6F, - 0x77, 0xB3, 0x92, 0x26, 0x6D, 0x94, 0x3A, 0xC2, 0xAC, 0xB1, 0x28, 0xE3, 0xBA, 0xBD, 0x31, 0xFD, - 0xC1, 0x5F, 0x0B, 0x98, 0x83, 0xF6, 0xC1, 0x38, 0x04, 0x08, 0x00, 0x40, 0x25, 0x7E, 0x84, 0x81, - 0x70, 0xE1, 0x49, 0xFE, 0x67, 0xBB, 0x60, 0xE7, 0x0A, 0xD5, 0xC8, 0x13, 0x89, 0xA4, 0xB0, 0xD4, - 0x20, 0x18, 0x13, 0xAF, 0x40, 0xC5, 0x87, 0x38, 0x78, 0x31, 0xCF, 0x24, 0x24, 0xA8, 0x5F, 0xE2, - 0x52, 0xAC, 0x02, 0x88, 0xAB, 0x37, 0x52, 0x10, 0x17, 0xC8, 0xE4, 0x66, 0xA8, 0x04, 0x55, 0x83, - 0x17, 0x63, 0xA3, 0xC8, 0xF3, 0x0B, 0x45, 0x13, 0x32, 0x51, 0x70, 0x5B, 0x93, 0x16, 0x80, 0xCE, - 0x4B, 0x30, 0x01, 0xCC, 0xD8, 0x24, 0x6C, 0x31, 0x52, 0x4C, 0x83, 0x20, 0x80, 0xE3, 0x47, 0x95, - 0xA0, 0x76, 0xF6, 0xF4, 0x2A, 0x79, 0x7B, 0x19, 0x71, 0x2C, 0x31, 0x9F, 0x95, 0x31, 0x54, 0xF2, - 0x20, 0x29, 0x71, 0x37, 0x10, 0x70, 0x51, 0x25, 0x0E, 0x64, 0x8D, 0xC0, 0x40, 0xDA, 0xD4, 0x25, - 0x38, 0x6E, 0x36, 0x7A, 0x30, 0x23, 0xB2, 0x5B, 0xA2, 0x6D, 0xD9, 0xE8, 0x58, 0x15, 0x9E, 0xFB, - 0x25, 0x6B, 0x25, 0x4A, 0xA7, 0xCA, 0xE0, 0xA9, 0xED, 0x4D, 0xA2, 0x84, 0x29, 0x0F, 0x2D, 0x2D, - 0xD3, 0xDE, 0xFF, 0xFE, 0xD8, 0xC6, 0x9A, 0xEE, 0xA5, 0xBD, 0xA9, 0x6B, 0xFB, 0xD8, 0xF3, 0x1E, - 0xC1, 0x7C, 0xAD, 0x7B, 0x4E, 0x0D, 0x98, 0xC2, 0xCD, 0xBD, 0x9F, 0x6B, 0x3A, 0xF2, 0x77, 0x4A, - 0x45, 0xA5, 0x77, 0xA0, 0x08, 0x00, 0x00, 0x66, 0xE1, 0x00, 0x1A, 0x54, 0x23, 0x50, 0x00, 0x63, - 0xB5, 0x51, 0xF0, 0x2F, 0x50, 0x02, 0x0E, 0x34, 0x62, 0x35, 0x93, 0x87, 0x15, 0xAC, 0xF6, 0x28, - 0xC4, 0x16, 0x47, 0x15, 0x53, 0x04, 0xEA, 0xAD, 0xD0, 0xB3, 0x1F, 0xF4, 0x64, 0x09, 0x9E, 0x50, - 0x7D, 0x00, 0x47, 0x06, 0x15, 0x5C, 0x46, 0x08, 0x04, 0x47, 0x49, 0x94, 0x46, 0x56, 0x11, 0x06, - 0x4F, 0x9A, 0xE7, 0xA7, 0x93, 0x86, 0x2F, 0x90, 0x26, 0x7E, 0x2C, 0xE6, 0x49, 0x87, 0xA6, 0x0E, - 0x8B, 0x27, 0x9E, 0x50, 0xD0, 0xB3, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8F, 0x04, 0xAA, 0x34, 0xCC, - 0x03, 0xBA, 0xCA, 0x70, 0x2E, 0x44, 0x29, 0xC4, 0x14, 0xC3, 0xA2, 0x11, 0xE0, 0xD1, 0x30, 0x0E, - 0xEF, 0x25, 0x08, 0xC8, 0x1E, 0xA9, 0x34, 0x50, 0xAA, 0x9A, 0x11, 0x7C, 0xA2, 0x99, 0x95, 0x76, - 0x6E, 0x9A, 0xA6, 0x11, 0x81, 0x48, 0x24, 0x36, 0x9A, 0x05, 0x91, 0xC3, 0x08, 0x70, 0xE2, 0x8F, - 0xAB, 0x4C, 0x00, 0x55, 0x01, 0x2D, 0x80, 0x11, 0xF1, 0x0B, 0x82, 0xA1, 0x81, 0xC3, 0x25, 0x48, - 0x01, 0x65, 0x0E, 0x32, 0xB0, 0x36, 0x40, 0x6A, 0x84, 0xE0, 0x59, 0xE4, 0x64, 0x9B, 0xA1, 0x00, - 0x42, 0xC2, 0x30, 0x00, 0x6F, 0x80, 0x28, 0x0B, 0x74, 0x6F, 0x8A, 0xE8, 0x88, 0xCC, 0x1A, 0x22, - 0x3D, 0x56, 0xDB, 0xBA, 0x44, 0x1C, 0x84, 0x08, 0x2C, 0x9D, 0x7C, 0xA4, 0x86, 0x3C, 0xFF, 0xFE, - 0xCA, 0xA5, 0x1D, 0xFC, 0xB2, 0xEE, 0xBB, 0xFF, 0x85, 0x36, 0xED, 0xD2, 0x2E, 0xCA, 0x8E, 0x93, - 0x4F, 0x75, 0xB1, 0xD7, 0xC3, 0x95, 0x26, 0xDD, 0x48, 0x22, 0x2D, 0x0E, 0xB7, 0x6C, 0xC3, 0x02, - 0x80, 0x00, 0x06, 0x7A, 0xC6, 0x07, 0x75, 0x85, 0x36, 0x03, 0x8A, 0x9D, 0x6B, 0xAB, 0x15, 0xDD, - 0x67, 0xB9, 0x6B, 0xC2, 0xB2, 0x6B, 0xDD, 0x04, 0x7F, 0xF0, 0xF4, 0x52, 0x8C, 0x60, 0xD7, 0xB1, - 0xA2, 0x95, 0x09, 0xD3, 0xE5, 0xEB, 0x0C, 0x04, 0x81, 0x3D, 0xE4, 0x96, 0xE0, 0x40, 0x06, 0x0D, - 0x09, 0xCD, 0x4C, 0xA8, 0xC2, 0x12, 0x23, 0x18, 0x99, 0x33, 0x56, 0x94, 0xA3, 0x1E, 0x71, 0x0A, - 0x8F, 0x1F, 0x49, 0x89, 0x8C, 0x10, 0x9E, 0xF0, 0xCA, 0x74, 0x32, 0xD8, 0xB1, 0xA3, 0x14, 0x99, - 0x92, 0x84, 0xB4, 0x80, 0x30, 0x79, 0x3A, 0x72, 0x10, 0xA5, 0x8D, 0x50, 0xB8, 0xB5, 0x99, 0x48, - 0xF0, 0x12, 0xA9, 0x5B, 0xE5, 0x69, 0x49, 0xCA, 0x1B, 0x18, 0xD6, 0xB3, 0xA2, 0x32, 0x15, 0xE2, - 0x17, 0x17, 0x9E, 0x03, 0x15, 0x38, 0x1D, 0x62, 0xCB, 0x39, 0x00, 0x4F, 0x51, 0xC2, 0x8B, 0x20, - 0x91, 0xC2, 0x1E, 0x46, 0xA5, 0x42, 0x78, 0xA0, 0x08, 0x82, 0x96, 0xC5, 0x18, 0xAB, 0x0D, 0xAB, - 0x0E, 0x38, 0xF0, 0xD0, 0xD0, 0xA3, 0x10, 0xCB, 0x22, 0x5D, 0x3F, 0x8F, 0xFE, 0x5A, 0xFA, 0x3E, - 0xFF, 0xFF, 0xFF, 0xFF, 0xCA, 0xE4, 0x17, 0x63, 0x91, 0x28, 0x02, 0x86, 0x34, 0x94, 0x92, 0xE7, - 0x8A, 0xF6, 0x12, 0x7F, 0xC5, 0x77, 0xC7, 0x1E, 0x89, 0xC9, 0x68, 0xB2, 0x80, 0x80, 0x04, 0x11, - 0x00, 0x52, 0xF0, 0x09, 0xA1, 0x10, 0xEE, 0xDA, 0x36, 0x5B, 0x31, 0x96, 0x9C, 0x1C, 0xD9, 0x5E, - 0xE4, 0xEB, 0x7F, 0x81, 0x99, 0xCC, 0x5E, 0x73, 0xFF, 0x88, 0xE0, 0x70, 0xFB, 0xFF, 0xFE, 0x9F, - 0xF7, 0x63, 0x3F, 0xFF, 0xB9, 0x47, 0x71, 0x01, 0x60, 0x78, 0xA2, 0x39, 0xF1, 0x55, 0x00, 0x00, - 0x07, 0x01, 0x1D, 0xC7, 0x42, 0xA3, 0x09, 0x27, 0xC3, 0x0A, 0x81, 0x03, 0x1E, 0x86, 0x43, 0xA7, - 0x00, 0x51, 0xA2, 0x00, 0xC4, 0xA3, 0x08, 0xC6, 0xFF, 0xFB, 0x92, 0x64, 0x0D, 0x0E, 0x04, 0x55, - 0x34, 0x4D, 0x9B, 0xB8, 0x4B, 0xE0, 0x33, 0x83, 0xD9, 0xDA, 0x24, 0x43, 0x3A, 0x11, 0x30, 0xD3, - 0x34, 0x4E, 0xE4, 0xEF, 0x90, 0xC9, 0x8C, 0xE8, 0x74, 0x80, 0x89, 0xE2, 0x30, 0x3C, 0x60, 0x1F, - 0x31, 0x1C, 0x0C, 0x49, 0x42, 0xA8, 0x2A, 0x28, 0x00, 0x18, 0x04, 0x03, 0x8D, 0x18, 0x89, 0x60, - 0xD2, 0x9E, 0x6A, 0x48, 0x72, 0x86, 0x03, 0x5C, 0x93, 0x4F, 0xA3, 0x71, 0x81, 0xDD, 0xB9, 0xDC, - 0xDA, 0x86, 0x51, 0x84, 0xE8, 0x86, 0x05, 0x4E, 0xFC, 0xB1, 0x25, 0x4D, 0x47, 0x00, 0x0B, 0xE1, - 0x9E, 0x09, 0x09, 0x9B, 0x2B, 0x32, 0xB1, 0x37, 0x02, 0xA3, 0x48, 0xBE, 0xB5, 0x93, 0x45, 0x93, - 0x42, 0x89, 0xC1, 0x07, 0xDF, 0xCD, 0xB2, 0xCA, 0x38, 0xAA, 0x4F, 0x74, 0xC4, 0xD7, 0xFF, 0xFE, - 0x5C, 0xBE, 0x7F, 0xFF, 0xF3, 0x2A, 0xEB, 0x14, 0xAC, 0x7C, 0x7B, 0x04, 0xA3, 0x88, 0x5D, 0xD0, - 0xCD, 0x69, 0x23, 0xB4, 0xC8, 0xFF, 0xEA, 0xAD, 0x85, 0x4B, 0xAD, 0xF1, 0x18, 0x04, 0x48, 0x00, - 0x00, 0x40, 0xE0, 0x2D, 0xBE, 0x84, 0x46, 0x09, 0x98, 0x6C, 0x32, 0xEF, 0xD5, 0xE0, 0xC3, 0xE5, - 0xB7, 0x07, 0xF5, 0x08, 0x80, 0x23, 0x08, 0xE8, 0x40, 0x70, 0x43, 0xB8, 0x40, 0xC8, 0xA1, 0x63, - 0x09, 0xCF, 0x82, 0x14, 0x35, 0xBD, 0x9F, 0xEE, 0xF4, 0x7F, 0xAE, 0x93, 0xC8, 0xA5, 0x5A, 0xC8, - 0x06, 0x06, 0x01, 0x80, 0xC0, 0x00, 0x20, 0xD0, 0x98, 0xA4, 0xC8, 0x20, 0xEC, 0xC3, 0xF4, 0xD8, - 0xCC, 0x75, 0x44, 0xC0, 0xF0, 0xC8, 0xC2, 0x43, 0x49, 0xD0, 0x30, 0x48, 0x08, 0x30, 0xE0, 0x45, - 0x6E, 0xA1, 0x60, 0x44, 0x20, 0x24, 0x00, 0x8B, 0x86, 0x1E, 0x08, 0x32, 0x85, 0xF0, 0xB5, 0xDA, - 0x32, 0xC3, 0x39, 0xEC, 0xF3, 0x08, 0x02, 0x09, 0x4D, 0x67, 0x8A, 0x5B, 0x5E, 0x56, 0xD4, 0xF3, - 0x86, 0x8B, 0xF4, 0xDA, 0x8C, 0x16, 0xDB, 0xB6, 0x25, 0x23, 0x2E, 0x14, 0x10, 0x4D, 0x59, 0xC1, - 0x96, 0xDE, 0x49, 0x96, 0x15, 0x4E, 0x22, 0x24, 0x6C, 0x65, 0x86, 0x10, 0x14, 0xED, 0x08, 0x82, - 0x1D, 0x06, 0xD6, 0x35, 0xF1, 0x58, 0x79, 0x98, 0xE2, 0xF4, 0xAA, 0xB9, 0xFA, 0xFC, 0x9B, 0xE5, - 0x1B, 0xE5, 0x4D, 0x2C, 0x80, 0xF4, 0x23, 0x0F, 0x1A, 0x40, 0x60, 0x32, 0xD1, 0xE7, 0x10, 0xB8, - 0xC9, 0x82, 0x40, 0x8C, 0x43, 0xFE, 0x1D, 0xEF, 0xE9, 0x43, 0x00, 0x34, 0xA1, 0x24, 0x00, 0x12, - 0x54, 0x0A, 0x11, 0xB2, 0xDC, 0xD9, 0x5A, 0xFA, 0x6F, 0xC6, 0x82, 0xA6, 0x10, 0x37, 0x4C, 0x55, - 0x2E, 0xA0, 0x9B, 0x21, 0xE3, 0xEB, 0x12, 0x75, 0xCC, 0xEF, 0xE4, 0xAD, 0xE5, 0x40, 0xE6, 0xD2, - 0x5B, 0xA1, 0xA8, 0xFF, 0x06, 0xE9, 0x42, 0x90, 0xD6, 0x02, 0x48, 0x9E, 0x00, 0x03, 0x04, 0xE9, - 0x30, 0x2C, 0x62, 0x36, 0xE0, 0x08, 0x28, 0x42, 0x8C, 0x3F, 0x22, 0xCF, 0x85, 0x1F, 0x8C, 0x53, - 0x09, 0x8C, 0x71, 0x42, 0x0E, 0xE0, 0x53, 0x28, 0x0C, 0xF6, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0F, - 0x04, 0x7B, 0x34, 0x4C, 0x93, 0xBA, 0xC1, 0xB4, 0x2F, 0xE6, 0x8A, 0x1D, 0x14, 0x28, 0x8E, 0x92, - 0x64, 0xD1, 0x30, 0x0E, 0xEF, 0x44, 0x80, 0xB6, 0x16, 0xE4, 0xC0, 0x30, 0x2C, 0x98, 0xE6, 0x7F, - 0xCC, 0x38, 0x20, 0xC3, 0x86, 0x01, 0x50, 0x0E, 0x39, 0x30, 0xAA, 0xE2, 0x4E, 0x80, 0xA1, 0x51, - 0x69, 0x5B, 0x83, 0x4C, 0xFA, 0xC3, 0x54, 0x0B, 0xD6, 0x15, 0x3A, 0xA8, 0x26, 0xDD, 0xB4, 0xE2, - 0x4E, 0x31, 0x64, 0x29, 0x35, 0x83, 0x12, 0xDB, 0xA8, 0x33, 0xE0, 0xFC, 0xB3, 0xE0, 0xD4, 0x2D, - 0x5A, 0x12, 0x2A, 0x10, 0x90, 0x05, 0x14, 0x2F, 0x78, 0xCB, 0x6E, 0xE8, 0x21, 0x28, 0x17, 0x69, - 0x1C, 0x1D, 0x63, 0x24, 0x88, 0x81, 0xDD, 0x01, 0xA2, 0xC2, 0xD9, 0x4C, 0x9F, 0xFF, 0xFF, 0x0E, - 0x7F, 0xD6, 0xE7, 0xFF, 0xFF, 0xCD, 0xE7, 0x21, 0xA9, 0x21, 0xF9, 0x14, 0xA6, 0x0B, 0xAF, 0x21, - 0xEF, 0x3F, 0xF7, 0xB9, 0x8E, 0x7B, 0xE6, 0xE5, 0x9D, 0xFD, 0x3D, 0xFD, 0xAA, 0x3C, 0x35, 0x0C, - 0x00, 0x28, 0x68, 0xA0, 0x00, 0x46, 0x50, 0x01, 0x9E, 0x22, 0x22, 0xDE, 0x8F, 0xE3, 0x40, 0x41, - 0xE2, 0xA8, 0x74, 0xFB, 0x09, 0x2C, 0xFB, 0x21, 0x09, 0xEB, 0x34, 0x7C, 0xE1, 0x5C, 0xF1, 0xCF, - 0xFE, 0x7F, 0xCF, 0x94, 0xBF, 0xF6, 0xDC, 0x28, 0xEE, 0xFF, 0x14, 0xB9, 0x36, 0x31, 0x1A, 0x59, - 0x88, 0x20, 0x02, 0x39, 0x26, 0x5C, 0x30, 0xB0, 0x44, 0x30, 0x4E, 0x61, 0x31, 0x7D, 0x44, 0x31, - 0xD3, 0xD3, 0x2F, 0xCD, 0x0E, 0xF9, 0x31, 0x41, 0xB3, 0xD8, 0x2F, 0x1A, 0x15, 0x0A, 0x1B, 0x38, - 0x8A, 0xCC, 0xAC, 0xE3, 0xE2, 0xD2, 0x20, 0x60, 0x00, 0x89, 0x00, 0x95, 0xC3, 0x3B, 0x80, 0xD0, - 0xBE, 0x26, 0x5E, 0xF7, 0xB6, 0x54, 0xB4, 0x2D, 0x27, 0x62, 0xA1, 0xCD, 0x1F, 0x16, 0x7C, 0x50, - 0x32, 0x13, 0x20, 0x2C, 0x8A, 0x11, 0x36, 0xC6, 0x26, 0x88, 0xD1, 0x42, 0x02, 0xC5, 0x02, 0xDC, - 0x33, 0x0E, 0x25, 0x65, 0x15, 0x02, 0x93, 0x4A, 0x0B, 0x88, 0x0A, 0x00, 0x0C, 0x44, 0x9D, 0x40, - 0xA0, 0x55, 0xD5, 0x38, 0xD0, 0x3A, 0x61, 0xC0, 0xEE, 0x6A, 0xA9, 0x98, 0x10, 0x51, 0xD2, 0xD4, - 0x33, 0xA8, 0x1A, 0xF7, 0xFF, 0xEB, 0x3B, 0xFF, 0x8F, 0xEF, 0xB8, 0x6F, 0x94, 0xB3, 0x31, 0x15, - 0xD7, 0x49, 0x5A, 0x15, 0xA8, 0xD3, 0x09, 0x7E, 0x27, 0xF9, 0xFF, 0xF8, 0xCF, 0x40, 0xB3, 0xF0, - 0x2C, 0x79, 0x34, 0xA0, 0x13, 0xAE, 0xD0, 0xD4, 0xD6, 0xBA, 0x73, 0xA3, 0x45, 0xF2, 0x9D, 0x44, - 0x3A, 0xE2, 0x09, 0xA9, 0x1E, 0xEB, 0xFD, 0xB4, 0x91, 0xEB, 0xDC, 0xEF, 0x8B, 0xFF, 0x52, 0x5E, - 0xBA, 0x87, 0x3F, 0xE1, 0x6E, 0xE1, 0x9C, 0x1C, 0xFF, 0x73, 0x8E, 0xC1, 0x72, 0xA7, 0x7C, 0x4A, - 0x58, 0x43, 0x06, 0x45, 0x33, 0x64, 0xB4, 0xF3, 0x12, 0xC1, 0x73, 0x12, 0x97, 0x53, 0xD3, 0x05, - 0xE1, 0xA1, 0xE0, 0xC0, 0x83, 0x5C, 0xC4, 0x97, 0x1A, 0xFC, 0x7F, 0xD5, 0xFF, 0xFB, 0x92, 0x64, - 0x0E, 0x0F, 0xF4, 0x72, 0x35, 0x4C, 0x03, 0xBA, 0xC9, 0xB0, 0x30, 0x85, 0xB9, 0x00, 0x01, 0xA6, - 0x6C, 0x11, 0x60, 0xD3, 0x32, 0x0E, 0xEF, 0x25, 0x00, 0xC6, 0x17, 0x64, 0xC0, 0x10, 0x2C, 0x30, - 0xA2, 0xB9, 0x9D, 0x9E, 0x6F, 0x13, 0x1C, 0x24, 0xC6, 0x26, 0x0C, 0x12, 0x5A, 0x42, 0x26, 0x39, - 0x0F, 0x60, 0x9B, 0x69, 0xAC, 0xD8, 0xCB, 0xCA, 0xAF, 0xDF, 0xF9, 0x3D, 0x85, 0x52, 0x7B, 0xE0, - 0xA5, 0x7E, 0xD9, 0xD3, 0xB8, 0xB4, 0x0E, 0x58, 0xAA, 0x91, 0x72, 0x43, 0xCC, 0xF2, 0x14, 0xBC, - 0x44, 0x83, 0xF7, 0x04, 0x01, 0xA4, 0x6C, 0x02, 0x2B, 0x40, 0x49, 0xBA, 0xA6, 0x7A, 0x0F, 0x72, - 0x72, 0x11, 0x28, 0xF6, 0x89, 0x01, 0x01, 0x43, 0x6F, 0xFC, 0x3A, 0xA3, 0xEE, 0x1B, 0xAE, 0x93, - 0x57, 0x24, 0x92, 0x1F, 0xFF, 0xFC, 0x7B, 0xFF, 0xAB, 0x1A, 0xBD, 0x57, 0x9F, 0x55, 0xF1, 0xA7, - 0xD5, 0x24, 0x2B, 0x37, 0xE6, 0xF3, 0x54, 0x9C, 0xEF, 0xFF, 0x31, 0x8E, 0xC0, 0x57, 0xEE, 0x27, - 0xDC, 0xE7, 0x67, 0x09, 0x26, 0x49, 0x94, 0x62, 0x5A, 0xA4, 0x4A, 0xE9, 0x9E, 0x99, 0x89, 0x79, - 0xFD, 0x42, 0x64, 0x49, 0x8E, 0x31, 0x33, 0xFF, 0xF1, 0xA0, 0x53, 0xCF, 0xFB, 0x93, 0x3E, 0x8E, - 0xB4, 0x89, 0x2F, 0xFF, 0xBB, 0x1B, 0xC4, 0x0D, 0xC3, 0xAF, 0xF6, 0x31, 0x0D, 0xAD, 0x85, 0x82, - 0xF8, 0x7E, 0x75, 0x52, 0x88, 0xC2, 0x60, 0xA5, 0xFC, 0x61, 0x38, 0x1C, 0x61, 0xC1, 0x90, 0x78, - 0x50, 0x6A, 0x63, 0x87, 0x43, 0xCC, 0xA6, 0xCE, 0x06, 0x64, 0xCE, 0x26, 0x66, 0x38, 0x50, 0x04, - 0x61, 0x08, 0xA0, 0x25, 0x93, 0x1D, 0x93, 0x39, 0x92, 0x25, 0x26, 0x23, 0x1A, 0x16, 0xA1, 0x90, - 0x32, 0x09, 0x35, 0xE7, 0x12, 0x52, 0x98, 0x8B, 0x89, 0xC0, 0x94, 0xC6, 0x1B, 0x02, 0x7B, 0x26, - 0xC2, 0x28, 0x30, 0x10, 0xA8, 0x09, 0xC0, 0xE4, 0x93, 0x4D, 0x0F, 0xA3, 0x7B, 0x5C, 0x75, 0xC5, - 0x4A, 0xC9, 0x29, 0x85, 0x4B, 0x8D, 0x05, 0xCB, 0x56, 0xB5, 0x6D, 0x37, 0x25, 0x69, 0xB2, 0x91, - 0xA9, 0x6F, 0x96, 0x99, 0xF2, 0xA5, 0x47, 0x0D, 0xAE, 0xC9, 0xEB, 0x69, 0xD1, 0x14, 0x7C, 0x2F, - 0x7F, 0xFE, 0xEA, 0x7F, 0xE1, 0xBB, 0x93, 0xFA, 0xCB, 0xFF, 0xE0, 0xDA, 0x6F, 0x95, 0xD1, 0xD0, - 0xC1, 0xFC, 0x66, 0x73, 0xBD, 0xFF, 0xDF, 0xE4, 0xA0, 0x2F, 0xC4, 0x92, 0x07, 0xC4, 0x6F, 0x4E, - 0x6C, 0x7B, 0x21, 0x0C, 0x4B, 0xC6, 0xA3, 0x75, 0xD3, 0xB4, 0x43, 0x27, 0xA6, 0x4F, 0xAC, 0xC4, - 0x62, 0xB5, 0xCB, 0xDF, 0xBD, 0xEF, 0xFF, 0x30, 0x41, 0x95, 0xC3, 0x54, 0x54, 0x9F, 0x03, 0xB3, - 0x86, 0x7E, 0x81, 0x2E, 0xF6, 0x15, 0xAD, 0xFF, 0xE5, 0x75, 0xCB, 0xFB, 0xCC, 0xF2, 0x64, 0xEA, - 0x0B, 0x81, 0x06, 0x05, 0x08, 0x66, 0x94, 0xD0, 0x26, 0x0A, 0x07, 0x26, 0x09, 0x33, 0x46, 0x43, - 0x1C, 0xA6, 0x07, 0x89, 0x46, 0x23, 0xBB, 0x00, 0xE2, 0x30, 0x46, 0x02, 0x19, 0x68, 0xFF, 0xFB, - 0x92, 0x64, 0x0F, 0x0F, 0xF4, 0x78, 0x34, 0xCC, 0x83, 0xB9, 0x5B, 0x70, 0x30, 0xE5, 0x99, 0x60, - 0x15, 0x27, 0x78, 0x11, 0xC4, 0xD3, 0x32, 0x0E, 0xEF, 0x25, 0x00, 0xC5, 0x1A, 0x64, 0xC0, 0x30, - 0x20, 0x30, 0x0F, 0x21, 0x89, 0x80, 0xE3, 0x48, 0x40, 0x4C, 0x0D, 0x1F, 0x4F, 0xF7, 0xCA, 0x1B, - 0x10, 0x24, 0x25, 0x2A, 0x87, 0x16, 0xA6, 0x5A, 0xA5, 0x4C, 0x3E, 0x38, 0x96, 0x96, 0x9D, 0x28, - 0x66, 0x24, 0xB0, 0x88, 0xD0, 0x2A, 0x22, 0xED, 0x0A, 0x82, 0x01, 0x10, 0xAC, 0xC8, 0x30, 0x2C, - 0xA9, 0x10, 0xE8, 0x7A, 0x50, 0x03, 0x4E, 0x63, 0x02, 0xC2, 0x30, 0xA3, 0x1D, 0xA5, 0x58, 0xAC, - 0xA4, 0x73, 0xA2, 0x98, 0x56, 0x85, 0x6C, 0x49, 0xF2, 0x23, 0x22, 0xC8, 0xDB, 0x77, 0xD4, 0x56, - 0x79, 0x19, 0x95, 0x8E, 0xB1, 0x08, 0x6E, 0x3B, 0x64, 0x29, 0x8F, 0x9B, 0xAD, 0x23, 0xB6, 0xE4, - 0x0D, 0x2F, 0xCA, 0x58, 0x52, 0x62, 0x5C, 0x4D, 0x23, 0xD3, 0xDF, 0xFD, 0x13, 0xC9, 0x18, 0x94, - 0xA0, 0x04, 0xD7, 0x05, 0x7F, 0xFF, 0xFE, 0xA1, 0x72, 0x01, 0x0B, 0xA0, 0xBB, 0x59, 0x34, 0x91, - 0x34, 0x36, 0x60, 0xE9, 0x17, 0xF1, 0xA5, 0x83, 0x46, 0x2D, 0xE1, 0x72, 0x05, 0x49, 0x7E, 0x5F, - 0x28, 0x37, 0x21, 0x94, 0x1A, 0xD0, 0xFE, 0x50, 0xC7, 0xA1, 0x22, 0x1E, 0xAF, 0xC7, 0xCE, 0x33, - 0xC5, 0x8B, 0x0F, 0x20, 0xBD, 0x00, 0x41, 0x39, 0xB2, 0xCC, 0x81, 0x41, 0x16, 0x61, 0xC9, 0xC0, - 0x74, 0xA8, 0xA6, 0x1C, 0xE4, 0x73, 0x73, 0x67, 0x18, 0x22, 0x62, 0x41, 0x07, 0x06, 0xB2, 0x06, - 0x0F, 0x31, 0x60, 0x60, 0x70, 0x19, 0x85, 0x4F, 0x98, 0xC4, 0x03, 0x58, 0x05, 0x25, 0x32, 0xD5, - 0x12, 0x65, 0x8F, 0x1B, 0xC2, 0xC9, 0xA1, 0xA5, 0x90, 0xF6, 0xAA, 0x8B, 0x48, 0x7A, 0x19, 0x63, - 0x65, 0x0C, 0x54, 0x2C, 0x48, 0x18, 0xF5, 0x9C, 0xBD, 0xD4, 0xF1, 0x61, 0x14, 0x22, 0x6C, 0x02, - 0x33, 0x15, 0x02, 0x8B, 0x26, 0xEC, 0xD4, 0xAC, 0xA1, 0x46, 0x32, 0x7E, 0x18, 0xDF, 0x2D, 0xA0, - 0x30, 0x2B, 0xC4, 0x61, 0x47, 0x96, 0x22, 0x85, 0x93, 0x8E, 0x64, 0x2A, 0x18, 0x42, 0xA8, 0x31, - 0x95, 0x94, 0x06, 0xF5, 0x39, 0x5C, 0xFF, 0xFF, 0xFF, 0xC7, 0x79, 0x7D, 0x8B, 0xFD, 0xEE, 0x3B, - 0xE6, 0x98, 0x6C, 0x17, 0x39, 0x96, 0xA7, 0x70, 0xFF, 0xFD, 0xC9, 0xA6, 0xA2, 0xB3, 0x0C, 0x31, - 0xAF, 0x5F, 0x41, 0xF2, 0x98, 0x58, 0xE8, 0x3A, 0xE9, 0xE4, 0x77, 0x28, 0x2A, 0x20, 0x87, 0xBF, - 0xE5, 0x58, 0xD4, 0x1E, 0x1C, 0x89, 0x86, 0x86, 0xBF, 0xFB, 0x0A, 0xE1, 0xC0, 0x80, 0x1F, 0x17, - 0xDB, 0x5C, 0x54, 0x7E, 0xCB, 0xFC, 0x0A, 0xFF, 0xA0, 0x97, 0xFA, 0x3F, 0x6F, 0xFF, 0x2C, 0xF9, - 0xB7, 0x73, 0x85, 0xEA, 0x2A, 0x81, 0x4C, 0x3C, 0x0A, 0x3B, 0x8C, 0x40, 0xCE, 0xC2, 0x03, 0x21, - 0xCC, 0x4F, 0x6A, 0xE8, 0x32, 0xA8, 0x54, 0xC9, 0x0D, 0x13, 0x29, 0x13, 0xCC, 0x5E, 0x14, 0x32, - 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x74, 0x64, 0x34, 0xCC, 0x83, 0x99, 0x6B, 0xE0, 0x31, 0x06, - 0x99, 0x45, 0x08, 0xE6, 0xC6, 0x92, 0x04, 0xD3, 0x30, 0x0E, 0xEF, 0x26, 0x80, 0xBF, 0x19, 0x66, - 0x54, 0x54, 0x09, 0xF1, 0x92, 0x29, 0x70, 0x10, 0x8E, 0x53, 0xA0, 0x2C, 0x73, 0x31, 0xE1, 0x94, - 0x68, 0x2A, 0x10, 0x3D, 0x57, 0xEC, 0x8A, 0x41, 0x29, 0x6B, 0x9A, 0xAC, 0xD1, 0x1F, 0xB7, 0x6D, - 0x81, 0x3F, 0x8C, 0x4C, 0x1D, 0x12, 0x1B, 0x97, 0x3C, 0x1C, 0x98, 0x74, 0x61, 0x60, 0x5E, 0x54, - 0xD1, 0x2F, 0x62, 0x9E, 0x5E, 0xE3, 0xC2, 0xCB, 0x87, 0x9E, 0x6C, 0x8B, 0x48, 0x9A, 0xC4, 0xEC, - 0x3D, 0xDE, 0x22, 0x41, 0x8F, 0x06, 0xCF, 0x03, 0x25, 0x10, 0xD2, 0x15, 0x52, 0x4E, 0x43, 0x0F, - 0x48, 0xA6, 0x01, 0x83, 0xAE, 0x44, 0x75, 0x86, 0x9D, 0x00, 0xB5, 0x94, 0x75, 0x7F, 0x38, 0x83, - 0xFA, 0xC6, 0x0C, 0x2D, 0xA2, 0x66, 0x64, 0x50, 0x1D, 0x1B, 0x99, 0x86, 0x20, 0x0D, 0x05, 0xD2, - 0x5C, 0x61, 0x46, 0x39, 0xE0, 0x40, 0x00, 0x1C, 0x57, 0xFD, 0x08, 0xC7, 0x7D, 0xC1, 0x08, 0x88, - 0xA8, 0x19, 0x81, 0xD9, 0x4E, 0x80, 0x88, 0x4E, 0x7E, 0x8F, 0x46, 0x5F, 0x72, 0x27, 0x98, 0x25, - 0x96, 0xBE, 0xC8, 0x3C, 0xA4, 0xFF, 0xCE, 0x3B, 0x1B, 0x90, 0x3B, 0xE3, 0xE1, 0x95, 0x3D, 0x3C, - 0x28, 0x4F, 0x19, 0xCB, 0x0A, 0xD7, 0x90, 0x0A, 0x0C, 0x99, 0x89, 0x59, 0x98, 0xFA, 0x12, 0x98, - 0xF8, 0x66, 0x9E, 0xC0, 0xA9, 0x18, 0xA4, 0x15, 0x99, 0x6A, 0xC0, 0x9B, 0x19, 0x58, 0x73, 0x49, - 0xD1, 0xE2, 0x8F, 0x01, 0x98, 0x00, 0x01, 0x9A, 0x04, 0x02, 0x1C, 0x4F, 0x36, 0xC2, 0x27, 0x2C, - 0xD2, 0x12, 0x22, 0xCC, 0x56, 0x52, 0x94, 0xF4, 0x3C, 0x83, 0x16, 0x73, 0x51, 0x71, 0xDE, 0xC6, - 0x18, 0x63, 0x06, 0xCC, 0x16, 0x0D, 0x20, 0xC2, 0xA7, 0x39, 0x2D, 0xAA, 0x46, 0x19, 0xC2, 0xC4, - 0x46, 0x07, 0x53, 0x06, 0xEE, 0x38, 0xBA, 0x34, 0xD0, 0x85, 0x17, 0x7C, 0xCC, 0xCF, 0xD1, 0x60, - 0x42, 0x29, 0xA5, 0x42, 0x40, 0x2E, 0x41, 0xB1, 0x5D, 0x74, 0x69, 0x91, 0xD6, 0xC2, 0x31, 0x32, - 0x4C, 0xC3, 0x25, 0x50, 0xD6, 0x77, 0x97, 0x7B, 0xF2, 0xDE, 0x7F, 0xFE, 0xF3, 0xD5, 0x14, 0xC7, - 0xFF, 0xFF, 0xD0, 0xC5, 0x20, 0x98, 0xD7, 0x61, 0x6E, 0x67, 0x3B, 0xFE, 0xE8, 0x53, 0x35, 0xA5, - 0xF8, 0xF0, 0xBD, 0x2D, 0x7E, 0xFC, 0x00, 0x60, 0x7F, 0xFA, 0x07, 0x14, 0x09, 0xA2, 0x0C, 0xA6, - 0x9F, 0x26, 0x96, 0xD7, 0x14, 0x20, 0x38, 0x51, 0x7E, 0x06, 0xC2, 0x25, 0x4A, 0x58, 0xC2, 0x7F, - 0xFC, 0xE0, 0xD8, 0xB8, 0xEF, 0x47, 0xA9, 0x81, 0x61, 0x10, 0x8B, 0xB7, 0xF9, 0x5F, 0xF2, 0xD4, - 0x8D, 0xE8, 0xC0, 0xD4, 0xBE, 0x15, 0x00, 0xC0, 0x04, 0xB5, 0x30, 0x24, 0x56, 0x32, 0x32, 0x6C, - 0x31, 0x5C, 0x16, 0x00, 0xA1, 0x46, 0xCE, 0x2A, 0x66, 0x08, 0x20, 0x6E, 0x4F, 0xA7, 0x2E, 0x18, - 0x60, 0xE8, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0D, 0x04, 0x6D, 0x34, 0xCD, 0x13, 0xBB, 0xC9, 0x40, - 0x34, 0x46, 0x79, 0x85, 0x1D, 0x22, 0x7C, 0x51, 0x34, 0xD3, 0x32, 0x0E, 0xE9, 0xAD, 0xC0, 0xC8, - 0xA3, 0xE7, 0x5C, 0x11, 0x8A, 0x8A, 0x66, 0x8C, 0xAC, 0x21, 0x00, 0x31, 0x51, 0x54, 0x4F, 0x10, - 0x2E, 0x9A, 0xF8, 0xE8, 0x29, 0x6D, 0x32, 0x02, 0x15, 0x97, 0xB9, 0x7B, 0x76, 0x21, 0xFF, 0x94, - 0xB8, 0x94, 0xD2, 0x88, 0x12, 0x52, 0x4A, 0x64, 0x6D, 0x96, 0x86, 0x1A, 0x0E, 0x07, 0x8F, 0xE2, - 0xA5, 0x02, 0x1D, 0x20, 0xB6, 0xAD, 0x30, 0xCC, 0xB1, 0x2C, 0x1A, 0xA0, 0x81, 0xE7, 0xA5, 0xC8, - 0x07, 0xD8, 0xEB, 0x82, 0x5E, 0x22, 0x15, 0xBB, 0x20, 0x39, 0xFC, 0x7E, 0xA8, 0xF1, 0x92, 0x37, - 0x96, 0x83, 0x9B, 0x9D, 0x6C, 0x63, 0x42, 0x48, 0xE2, 0x19, 0xD6, 0x95, 0x73, 0xFF, 0xEA, 0x5A, - 0xB9, 0x85, 0x37, 0x7F, 0xFF, 0xF7, 0x7A, 0xAC, 0xA6, 0xBC, 0xB6, 0x27, 0x39, 0xFF, 0xA7, 0xDA, - 0x05, 0x86, 0x63, 0xB1, 0x58, 0xEC, 0x52, 0xF8, 0x20, 0x00, 0x02, 0x85, 0xFF, 0xEA, 0x0D, 0x11, - 0x4B, 0xB6, 0x79, 0x4B, 0xF5, 0xD4, 0xC2, 0x4A, 0x7B, 0x38, 0x8A, 0xF5, 0xAA, 0xCE, 0xD9, 0x4B, - 0x9A, 0xFA, 0x17, 0xA4, 0x8A, 0xFF, 0xFF, 0xA7, 0x44, 0xD1, 0xFF, 0x7D, 0x09, 0x33, 0x91, 0x64, - 0x59, 0x7F, 0xF9, 0xBE, 0x1B, 0xAB, 0x1D, 0xFD, 0x86, 0x45, 0x14, 0x06, 0x0E, 0x05, 0x8C, 0x20, - 0x01, 0x8D, 0xAD, 0x2E, 0xCC, 0xBC, 0x0D, 0x4C, 0x5B, 0x16, 0x0F, 0x65, 0x17, 0xC1, 0x46, 0x59, - 0x8E, 0x22, 0x38, 0x19, 0xDE, 0x30, 0x0C, 0x5F, 0x31, 0xE4, 0x10, 0x07, 0x0D, 0x26, 0x0A, 0x01, - 0x22, 0x43, 0x10, 0x24, 0x71, 0x31, 0x7A, 0x04, 0xB5, 0x19, 0x61, 0x89, 0xBC, 0xEF, 0xCA, 0x26, - 0x69, 0xA1, 0xB9, 0xB5, 0x6B, 0x6A, 0x59, 0xC7, 0x2D, 0xC5, 0x84, 0x60, 0x0B, 0x7A, 0xAD, 0x02, - 0x43, 0x95, 0xFC, 0x38, 0xA9, 0x1A, 0x18, 0xA8, 0xA0, 0xE0, 0x09, 0xE8, 0x10, 0x8E, 0x26, 0xDC, - 0xC8, 0x80, 0x59, 0x30, 0x6C, 0x8A, 0x0E, 0x03, 0x87, 0x1F, 0x73, 0x69, 0x8C, 0x54, 0x40, 0x89, - 0xEC, 0xCC, 0x75, 0xCE, 0x71, 0x6C, 0x2F, 0x4A, 0x18, 0xAD, 0x80, 0x60, 0x36, 0xFE, 0x09, 0x54, - 0xA4, 0xB2, 0xFD, 0xFA, 0xEA, 0xF5, 0x54, 0x60, 0xAE, 0x21, 0xCB, 0xBC, 0x6A, 0x22, 0x94, 0x81, - 0xC6, 0x3A, 0x1A, 0x8E, 0x33, 0x68, 0x10, 0x00, 0x04, 0x98, 0x04, 0x1F, 0xF3, 0x08, 0x42, 0xA6, - 0x6A, 0xF6, 0xB0, 0x09, 0xC8, 0x88, 0x58, 0x00, 0x90, 0x44, 0xA1, 0x99, 0x46, 0x81, 0xFF, 0x0E, - 0x9D, 0x0C, 0xE6, 0x2A, 0x95, 0xBF, 0xE9, 0x5E, 0xBD, 0xFC, 0x83, 0xF4, 0xD7, 0x7F, 0xFF, 0xF9, - 0x17, 0xCA, 0xC8, 0x67, 0x7A, 0xFB, 0xC5, 0x3A, 0x68, 0x22, 0x30, 0x41, 0xE5, 0xB9, 0x66, 0x6F, - 0x0B, 0x18, 0x89, 0xFA, 0x6B, 0x8F, 0x20, 0x20, 0x36, 0x6A, 0xC3, 0x99, 0xBB, 0x42, 0x26, 0x19, - 0x11, 0x99, 0x69, 0x8A, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x14, 0x52, 0x34, 0xCC, 0x83, 0x9A, - 0x6B, 0xE0, 0x31, 0xC6, 0x99, 0x70, 0x09, 0x22, 0x7A, 0x12, 0x90, 0xD3, 0x30, 0x0E, 0xE9, 0xEF, - 0x80, 0xBB, 0x90, 0x26, 0xB8, 0x71, 0x95, 0xD0, 0x1C, 0x0A, 0x1D, 0x1D, 0x00, 0x01, 0x86, 0x1E, - 0x3C, 0x9B, 0xA8, 0x68, 0xF4, 0x18, 0x74, 0x2C, 0x60, 0xC0, 0xD3, 0xC5, 0x5D, 0xC6, 0xE7, 0x4F, - 0x6E, 0x2C, 0xD0, 0x7A, 0xC2, 0x24, 0x50, 0xE2, 0x19, 0x89, 0x01, 0x7F, 0xD3, 0x55, 0x23, 0xAA, - 0x25, 0x93, 0x96, 0x8A, 0x61, 0x06, 0x53, 0xD0, 0xC5, 0x0C, 0xA5, 0x5A, 0x28, 0x42, 0xD5, 0x41, - 0x21, 0x49, 0x90, 0x97, 0x54, 0xE6, 0x34, 0x6F, 0x44, 0x69, 0x86, 0x95, 0x4F, 0x8B, 0x08, 0x44, - 0xB8, 0x53, 0xD9, 0x24, 0x93, 0x35, 0x18, 0xE0, 0x88, 0x43, 0x42, 0x8C, 0x8B, 0x02, 0x7F, 0x9D, - 0x59, 0xBD, 0x6F, 0xEA, 0x2E, 0x9F, 0x2A, 0x1F, 0x4F, 0xEC, 0x24, 0xA6, 0xDA, 0xC9, 0xE2, 0xB8, - 0xE4, 0x28, 0x8F, 0x16, 0x0B, 0x62, 0x94, 0x6F, 0xFE, 0x83, 0x3E, 0x44, 0xCD, 0x42, 0x3E, 0xD0, - 0x39, 0x76, 0xA2, 0x40, 0xBA, 0x18, 0x95, 0x5E, 0x0E, 0x11, 0x12, 0x15, 0x2B, 0x1D, 0x8A, 0xB6, - 0x14, 0xAF, 0xFF, 0xF6, 0xE2, 0x70, 0x70, 0x10, 0xEA, 0x61, 0x82, 0xB7, 0xEB, 0xDC, 0x8F, 0x85, - 0xE0, 0x5F, 0x37, 0x9D, 0x94, 0x48, 0xB0, 0x26, 0x04, 0x00, 0x66, 0x0F, 0x88, 0xC6, 0x58, 0xD9, - 0x86, 0x1E, 0x80, 0x46, 0x18, 0x13, 0x87, 0xC8, 0x23, 0x66, 0x2F, 0x03, 0x86, 0x25, 0xAA, 0x42, - 0xCE, 0x5A, 0x72, 0x8C, 0x9C, 0x85, 0xCC, 0x30, 0x5C, 0x0F, 0x2F, 0x98, 0x14, 0x21, 0x33, 0xB0, - 0x11, 0x45, 0x80, 0xA0, 0x82, 0x54, 0x28, 0xDA, 0x32, 0xE4, 0xD5, 0x6C, 0xAE, 0xB4, 0x3D, 0x4C, - 0xB5, 0xEB, 0x2E, 0x7B, 0x0D, 0x18, 0x2A, 0x06, 0x5A, 0xD6, 0x81, 0xC4, 0xC1, 0xA0, 0x5B, 0xAC, - 0x6C, 0x84, 0x08, 0x85, 0x49, 0x73, 0x48, 0x49, 0x05, 0x0B, 0xB2, 0xC8, 0xDF, 0x63, 0x26, 0x00, - 0x9A, 0xAD, 0x11, 0x2A, 0x34, 0x8F, 0x52, 0x10, 0x2B, 0x21, 0x6B, 0x39, 0xA6, 0x84, 0x13, 0x8C, - 0xAE, 0x5F, 0x27, 0xA1, 0x73, 0x2F, 0xC7, 0x29, 0x11, 0xEB, 0x26, 0x9A, 0x9E, 0x64, 0x9B, 0xFF, - 0xE4, 0x77, 0x01, 0x5F, 0x0B, 0x19, 0xBF, 0x87, 0x1C, 0xD2, 0x91, 0xB1, 0x0A, 0x5A, 0xD5, 0x1B, - 0x8D, 0x4B, 0x6B, 0xD0, 0xDC, 0x41, 0x27, 0xA0, 0x16, 0xB8, 0x1E, 0x87, 0x10, 0x00, 0x30, 0x00, - 0x80, 0x00, 0x00, 0x47, 0xF5, 0x7B, 0x7F, 0x1B, 0x04, 0x88, 0x04, 0xB8, 0xE3, 0x76, 0xAD, 0x71, - 0x3B, 0x01, 0xD3, 0x16, 0x39, 0x1C, 0x04, 0x47, 0x8D, 0x0F, 0x18, 0xE0, 0x71, 0x9F, 0xFC, 0x55, - 0x44, 0x60, 0xD9, 0x97, 0xF5, 0x73, 0xE4, 0xDC, 0xB0, 0x8D, 0x12, 0xD5, 0x06, 0x80, 0x06, 0x07, - 0x09, 0xE6, 0x90, 0xA3, 0x26, 0x3C, 0x03, 0x66, 0x16, 0xA4, 0xC7, 0x10, 0xA4, 0xA6, 0x21, 0x83, - 0xC6, 0x03, 0x05, 0xC6, 0x1F, 0x82, 0xFF, 0xFB, 0x92, 0x64, 0x0D, 0x0E, 0x04, 0x59, 0x34, 0xCC, - 0x83, 0xBA, 0x7B, 0x70, 0x34, 0x25, 0x79, 0x88, 0x28, 0xC2, 0x6E, 0x50, 0xD8, 0xC9, 0x34, 0x4E, - 0xED, 0x6D, 0xD0, 0xCB, 0x11, 0x68, 0xF4, 0x34, 0x96, 0x12, 0x85, 0xA4, 0x10, 0x16, 0xE8, 0xB0, - 0x14, 0x09, 0x52, 0x30, 0xC0, 0x40, 0xCC, 0x48, 0xDA, 0xF4, 0x57, 0x20, 0x00, 0xB0, 0x23, 0xC1, - 0x1E, 0x67, 0xA5, 0xE2, 0xCF, 0x50, 0x04, 0xD3, 0xC9, 0xD7, 0xA9, 0x04, 0x0B, 0xC9, 0x3A, 0xD0, - 0x4E, 0x5A, 0x26, 0xEA, 0xBC, 0x9D, 0x13, 0x04, 0x79, 0x04, 0xE6, 0x11, 0x50, 0x9B, 0x78, 0x09, - 0xCC, 0xB7, 0x2A, 0x9B, 0x46, 0x21, 0x4B, 0x46, 0xA4, 0x12, 0x05, 0x9A, 0xB0, 0xD0, 0x7B, 0x0D, - 0x1A, 0x22, 0xE4, 0x97, 0xFF, 0x09, 0xA5, 0x87, 0x96, 0xC9, 0x5A, 0x1C, 0xB5, 0xA3, 0xC3, 0xB5, - 0x70, 0xD7, 0xFF, 0xCB, 0x7C, 0xCD, 0x1E, 0x5C, 0x77, 0x92, 0xBD, 0xDD, 0xFA, 0x6F, 0xE5, 0x81, - 0xB7, 0x7A, 0xED, 0x4F, 0x98, 0x8A, 0x37, 0xAB, 0x0D, 0xCF, 0xDD, 0x18, 0x00, 0x04, 0x00, 0x10, - 0x0D, 0x16, 0x03, 0x85, 0xBF, 0xA8, 0xF7, 0x18, 0x21, 0x2F, 0x67, 0xD7, 0x42, 0xFB, 0x49, 0x64, - 0x34, 0xB0, 0xB3, 0x90, 0xA8, 0x26, 0xC5, 0x6F, 0x62, 0x8C, 0x74, 0xEF, 0xFF, 0xEC, 0x86, 0x3D, - 0x20, 0xDE, 0xE2, 0x10, 0x7D, 0x7F, 0xFF, 0xF9, 0x06, 0x43, 0xB3, 0x1F, 0xAE, 0xF1, 0xA5, 0xC3, - 0x05, 0x1D, 0x19, 0x08, 0x4D, 0x0E, 0x2A, 0xC3, 0x0A, 0xF0, 0x00, 0xEE, 0x73, 0xF9, 0x00, 0x61, - 0xE8, 0x18, 0x61, 0xE2, 0x4C, 0x62, 0x30, 0x18, 0x5E, 0xC0, 0x41, 0x60, 0xAC, 0x48, 0x00, 0x64, - 0x06, 0x02, 0x86, 0xA3, 0xCA, 0x2E, 0xDA, 0x7A, 0x0F, 0x03, 0x45, 0x9A, 0x22, 0xE0, 0x6C, 0x2E, - 0x4E, 0x72, 0xE5, 0x08, 0xA6, 0x51, 0xA9, 0x98, 0x29, 0xAD, 0xA7, 0x39, 0x28, 0x3A, 0x9B, 0xBD, - 0x8B, 0xBE, 0x3E, 0xB4, 0x04, 0x86, 0x5C, 0x03, 0x1C, 0x88, 0x07, 0x29, 0x35, 0xB6, 0x8F, 0x66, - 0x7A, 0xA0, 0xC0, 0x09, 0x92, 0xA4, 0x10, 0x02, 0x17, 0xB4, 0x49, 0xA5, 0x26, 0x49, 0x03, 0x68, - 0xE6, 0x4B, 0xB1, 0x62, 0xD7, 0xD3, 0xC7, 0x68, 0xF1, 0x60, 0xD9, 0x12, 0x86, 0x3F, 0xFC, 0xB3, - 0x75, 0xFE, 0xBD, 0x64, 0x09, 0xE1, 0x91, 0x3E, 0x0F, 0x0D, 0x69, 0x5F, 0x98, 0x1F, 0x24, 0x49, - 0xF0, 0x21, 0xDF, 0xFA, 0x91, 0x93, 0x48, 0x1A, 0xCA, 0x0D, 0x90, 0x04, 0x2B, 0x00, 0xC2, 0x78, - 0xC5, 0x38, 0x97, 0xF9, 0xC7, 0x2E, 0x9A, 0x80, 0x9C, 0x51, 0x8B, 0x69, 0x23, 0x34, 0xE9, 0xAF, - 0x2B, 0xDC, 0x9F, 0x6F, 0xC9, 0x4D, 0x3F, 0xE0, 0x41, 0xF8, 0x83, 0xFA, 0x9F, 0xDD, 0x67, 0xFB, - 0x04, 0x02, 0xC5, 0xDA, 0x5E, 0x4C, 0xA8, 0x30, 0x65, 0x00, 0x03, 0x06, 0x8E, 0x14, 0x0A, 0x1A, - 0xD7, 0xC0, 0x65, 0x42, 0x00, 0xCC, 0xA4, 0xE9, 0xD0, 0x20, 0x32, 0x50, 0xCD, 0x27, 0x63, 0x7E, - 0x01, 0x02, 0xE2, 0xC2, 0x47, 0x38, 0xD0, 0xC8, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x8E, 0x04, 0x87, - 0x34, 0xCC, 0x93, 0x9B, 0x6B, 0x74, 0x33, 0xA3, 0x6A, 0x0A, 0x20, 0x46, 0x6A, 0x90, 0xF0, 0xCD, - 0x36, 0x6E, 0xE9, 0xAB, 0xC0, 0xC8, 0x8D, 0xE8, 0x0C, 0x90, 0x8D, 0xC2, 0x10, 0x24, 0x01, 0x0F, - 0x00, 0x83, 0xF3, 0xB0, 0x18, 0x87, 0x85, 0x41, 0x97, 0x74, 0x86, 0x54, 0xB7, 0x5F, 0x54, 0x84, - 0x80, 0x5F, 0x04, 0xF9, 0x9F, 0x4E, 0x77, 0x75, 0x7F, 0x8F, 0x0D, 0x2F, 0xF2, 0x11, 0x10, 0x70, - 0x3A, 0xD3, 0x44, 0x07, 0xDC, 0x94, 0x10, 0xBA, 0xA8, 0x88, 0x66, 0x70, 0x06, 0x7C, 0x10, 0x21, - 0x03, 0x0C, 0x12, 0x65, 0x0F, 0xE2, 0xC8, 0x46, 0x53, 0x0C, 0x51, 0x72, 0x4B, 0x60, 0x18, 0xCA, - 0xED, 0xBE, 0x82, 0xC0, 0x56, 0x10, 0x6E, 0x72, 0xC5, 0x5C, 0x97, 0x27, 0x60, 0x35, 0x2F, 0xAA, - 0x03, 0xFB, 0x7D, 0x16, 0x41, 0xBD, 0x68, 0x2E, 0x53, 0x8F, 0x61, 0xC8, 0x3C, 0x07, 0x39, 0xF5, - 0x66, 0x47, 0xC6, 0xA1, 0x9C, 0xE2, 0xCF, 0x92, 0xBF, 0xF6, 0xDF, 0x85, 0xBA, 0x13, 0x40, 0x40, - 0xA0, 0x00, 0x12, 0xA0, 0x02, 0x46, 0x47, 0x2E, 0xB0, 0xBD, 0xFD, 0xC2, 0xAE, 0xAC, 0xF2, 0x87, - 0x69, 0x5A, 0x4B, 0x0F, 0x01, 0x06, 0x20, 0x4A, 0xD8, 0xDF, 0x8F, 0x54, 0x24, 0xF3, 0x15, 0x61, - 0xC4, 0x17, 0x02, 0x5E, 0x59, 0xFB, 0xBD, 0x03, 0xC6, 0x27, 0xAD, 0xA2, 0xBF, 0xF8, 0x91, 0xCE, - 0xF9, 0xA0, 0x38, 0x0F, 0x32, 0xAB, 0x98, 0x5A, 0xCF, 0x82, 0x83, 0xD3, 0x0C, 0x84, 0xA3, 0x83, - 0x06, 0x53, 0x11, 0x02, 0x23, 0x04, 0x53, 0xB3, 0x18, 0x01, 0x33, 0x01, 0x00, 0xC3, 0x17, 0x4C, - 0x61, 0x40, 0x08, 0xB1, 0x18, 0x7A, 0x40, 0x80, 0x91, 0x80, 0x1C, 0x18, 0x22, 0x52, 0x44, 0x52, - 0x1C, 0xD3, 0x51, 0x6C, 0x49, 0x1F, 0x14, 0x58, 0x45, 0xC2, 0xD8, 0xD8, 0x7B, 0xD0, 0xEF, 0xA1, - 0xA4, 0x91, 0x9F, 0x17, 0xED, 0x7C, 0x57, 0xC9, 0x78, 0x0F, 0x12, 0x5C, 0xA6, 0x47, 0x88, 0x2B, - 0x0B, 0x7C, 0x64, 0x00, 0x2E, 0x78, 0x06, 0x7E, 0xCA, 0x59, 0x02, 0x40, 0xC0, 0x4B, 0x35, 0xB0, - 0x8C, 0x04, 0x18, 0x22, 0x78, 0x35, 0x8E, 0x72, 0x78, 0xF9, 0x0A, 0x9B, 0x92, 0x26, 0xC6, 0xE1, - 0xC9, 0x19, 0x7D, 0xB9, 0xD6, 0xFA, 0xAB, 0x26, 0x90, 0x08, 0x44, 0xA0, 0xEF, 0x37, 0x7F, 0x5A, - 0x48, 0x1F, 0x30, 0x05, 0xBF, 0xF5, 0x6A, 0x7D, 0x88, 0x00, 0x00, 0x14, 0x02, 0x67, 0x0C, 0xEC, - 0x24, 0xC0, 0x28, 0x18, 0x6F, 0xA6, 0xD6, 0x10, 0x20, 0xCD, 0x5F, 0x12, 0x65, 0xC2, 0xD0, 0x9D, - 0xD4, 0xCC, 0x88, 0x4C, 0x1B, 0x27, 0x74, 0x31, 0x68, 0x1C, 0x38, 0xA1, 0x02, 0x00, 0x68, 0x0B, - 0x30, 0x73, 0x9F, 0xFE, 0xB2, 0x7F, 0x94, 0xFF, 0x0F, 0xE3, 0x0E, 0x2A, 0x00, 0x00, 0x07, 0x01, - 0xC1, 0x1D, 0x1A, 0x1B, 0x31, 0xC4, 0x10, 0x02, 0x30, 0xC8, 0x08, 0xE7, 0xAB, 0x30, 0x60, 0xDC, - 0xDB, 0x7E, 0xF3, 0x92, 0xA0, 0x4C, 0x04, 0x13, 0x34, 0x62, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0F, - 0x04, 0x7A, 0x34, 0x4E, 0x1B, 0x9A, 0x6B, 0x70, 0x2F, 0xA7, 0xEA, 0x6A, 0x18, 0x22, 0x8E, 0x91, - 0xA8, 0xCF, 0x38, 0x0E, 0xE9, 0xAD, 0xC8, 0xBA, 0x8E, 0x67, 0x08, 0x90, 0x99, 0xD2, 0x7C, 0x48, - 0x84, 0x62, 0x24, 0x10, 0x72, 0x84, 0x40, 0x14, 0x35, 0x76, 0xDA, 0xFA, 0x37, 0x82, 0x82, 0xC2, - 0xD7, 0x3B, 0xC8, 0xC6, 0xD2, 0x19, 0xDD, 0x41, 0x13, 0xCA, 0xFE, 0x8C, 0x82, 0x6B, 0x0D, 0x0D, - 0x9A, 0x34, 0x61, 0xD0, 0x4A, 0xD6, 0xD3, 0xE9, 0x64, 0xA1, 0x70, 0x65, 0xE2, 0x47, 0x33, 0x09, - 0x04, 0xB8, 0x2B, 0x88, 0xCF, 0x8F, 0x49, 0xA5, 0x30, 0x9F, 0x9E, 0x00, 0x11, 0x40, 0x9C, 0x00, - 0x61, 0xC3, 0xB0, 0x24, 0x6E, 0x5F, 0x90, 0x40, 0xB2, 0x08, 0xC3, 0x65, 0x4B, 0xBF, 0x5A, 0x1D, - 0xA7, 0x82, 0xBA, 0x15, 0x87, 0x1A, 0xB3, 0x17, 0xDF, 0xFE, 0x74, 0x94, 0x1F, 0xC7, 0x01, 0x3C, - 0x40, 0x50, 0xE8, 0x11, 0x4B, 0xC5, 0x31, 0xE6, 0x42, 0x2E, 0x7F, 0xE7, 0xA8, 0xAF, 0x42, 0x12, - 0x00, 0x11, 0x00, 0x04, 0x56, 0x02, 0xA8, 0x7D, 0x80, 0xB4, 0xF0, 0x21, 0x35, 0xDE, 0x12, 0x28, - 0xBF, 0xE9, 0x9E, 0x48, 0x52, 0xE3, 0x2C, 0xC1, 0x3D, 0xDA, 0x11, 0x88, 0x52, 0x62, 0x34, 0x85, - 0xF7, 0xFA, 0xFF, 0x5F, 0xFF, 0x92, 0xFA, 0xFF, 0xFF, 0xFD, 0x91, 0xB0, 0xC0, 0x8F, 0xD3, 0x64, - 0x10, 0x10, 0x19, 0x9A, 0x0D, 0x18, 0x48, 0x0C, 0x18, 0x3E, 0x44, 0x9A, 0x46, 0x52, 0x18, 0x12, - 0x33, 0x99, 0xC0, 0xFE, 0x9D, 0x32, 0x2F, 0x83, 0x07, 0x93, 0x2A, 0xC4, 0xC3, 0x04, 0x43, 0xF0, - 0xB9, 0x5C, 0x60, 0x60, 0x22, 0x01, 0x07, 0x0C, 0x2F, 0xA5, 0x4A, 0x00, 0x12, 0x18, 0x9D, 0xCE, - 0x4F, 0x57, 0x92, 0x91, 0xD1, 0x82, 0x14, 0x01, 0x26, 0xDE, 0x46, 0xD9, 0x92, 0x38, 0x0E, 0xDA, - 0xCC, 0x53, 0xA6, 0xDA, 0x52, 0xA2, 0xCE, 0x1A, 0x36, 0x87, 0x13, 0x52, 0x91, 0x0C, 0xC0, 0x80, - 0x6F, 0x59, 0x84, 0x24, 0xA2, 0x43, 0x81, 0x0C, 0x59, 0x36, 0x0C, 0x66, 0xEE, 0x04, 0x0C, 0x5A, - 0x04, 0xCD, 0x9A, 0xAA, 0x86, 0xA3, 0x8C, 0x04, 0x81, 0x38, 0x4B, 0x12, 0x50, 0xAE, 0x35, 0xF8, - 0xDC, 0xFB, 0x01, 0x97, 0x04, 0x01, 0x3D, 0xAB, 0x4B, 0xFF, 0xE9, 0x9B, 0x92, 0x41, 0x8C, 0x16, - 0x66, 0x23, 0xCF, 0x9B, 0x18, 0xA8, 0x4E, 0x02, 0xF0, 0x30, 0x87, 0x84, 0x00, 0x01, 0x86, 0xCC, - 0x88, 0xA9, 0x94, 0xC1, 0x14, 0x25, 0xB3, 0x55, 0xC5, 0x85, 0x48, 0x9A, 0x94, 0x4C, 0x11, 0xFE, - 0x19, 0x56, 0x53, 0x31, 0x5B, 0xBE, 0x72, 0xBB, 0xA3, 0xDA, 0xBC, 0xE5, 0x4B, 0x0A, 0x3E, 0x1C, - 0x11, 0x16, 0x6A, 0x3F, 0xD7, 0x27, 0x96, 0xCE, 0xBF, 0xF8, 0x6A, 0x8F, 0x18, 0x06, 0x00, 0x98, - 0xCC, 0x69, 0x98, 0x3E, 0x04, 0x85, 0x03, 0xD3, 0x66, 0x85, 0x03, 0x04, 0x80, 0x53, 0x10, 0x84, - 0x83, 0xBF, 0x45, 0x73, 0x13, 0x88, 0x73, 0x0B, 0x00, 0x50, 0x81, 0x40, 0xFF, 0xFB, 0x90, 0x64, - 0x10, 0x87, 0xF4, 0x56, 0x34, 0x4E, 0x83, 0xB9, 0x53, 0xE0, 0x32, 0xC6, 0x79, 0x30, 0x15, 0xA2, - 0xA6, 0x52, 0x28, 0xD1, 0x38, 0xAE, 0xE9, 0xAD, 0xC0, 0xC4, 0x98, 0xA5, 0x80, 0x24, 0x9E, 0x11, - 0xC0, 0x50, 0xF8, 0xCD, 0xF1, 0xA4, 0xB4, 0xE0, 0xC0, 0xE0, 0xC4, 0x20, 0x11, 0x23, 0x8C, 0x61, - 0x9C, 0x89, 0x96, 0x19, 0x10, 0x60, 0x50, 0x33, 0x53, 0x15, 0x02, 0x99, 0x9F, 0x94, 0x18, 0xDA, - 0xC5, 0x59, 0x33, 0x8B, 0x2F, 0xC9, 0x85, 0x80, 0x94, 0x96, 0x02, 0x25, 0x34, 0x4D, 0x20, 0x38, - 0x6B, 0x67, 0x34, 0x54, 0x80, 0xC2, 0xE7, 0x85, 0x34, 0x44, 0x44, 0x80, 0x30, 0x0D, 0x7D, 0x00, - 0x40, 0xA3, 0x9B, 0x4E, 0x9A, 0x58, 0x34, 0x77, 0x7C, 0x9F, 0x88, 0x3E, 0xBC, 0x56, 0x92, 0xDD, - 0xD9, 0x70, 0xF8, 0x74, 0xDF, 0x42, 0x4F, 0xFC, 0x3D, 0x16, 0x86, 0x01, 0x74, 0x02, 0xC3, 0xF1, - 0x49, 0xFA, 0x82, 0xC9, 0x52, 0x70, 0x6A, 0x0A, 0x48, 0xFC, 0x4D, 0xDA, 0xA4, 0x32, 0x97, 0xD5, - 0x8C, 0xFD, 0x03, 0xC0, 0x63, 0xB2, 0x8B, 0x9D, 0x6C, 0x4F, 0x24, 0x65, 0xD1, 0xCE, 0x58, 0x13, - 0x42, 0xF9, 0x0B, 0xFF, 0xE6, 0x03, 0xCC, 0x6A, 0x1D, 0xA3, 0xF4, 0xCC, 0xBE, 0x6C, 0xC8, 0xA8, - 0xE4, 0xBF, 0xFF, 0xFA, 0xF8, 0x75, 0xD4, 0x04, 0xE5, 0x31, 0x83, 0x38, 0xA8, 0x15, 0x28, 0x84, - 0x04, 0x30, 0x89, 0x04, 0x30, 0xE4, 0x04, 0x30, 0x38, 0x58, 0x30, 0xD5, 0x0D, 0x30, 0x04, 0x2E, - 0x31, 0x9D, 0x49, 0x3F, 0xD4, 0x64, 0x05, 0x28, 0xA6, 0x12, 0x04, 0xC5, 0x9D, 0x30, 0x14, 0x17, - 0x0A, 0x20, 0x81, 0x00, 0x20, 0x30, 0xF1, 0x90, 0x6A, 0x98, 0x25, 0xF6, 0x68, 0x72, 0xE6, 0xBF, - 0x12, 0xA5, 0x5D, 0x50, 0x43, 0x39, 0x43, 0x76, 0x44, 0xB7, 0x94, 0x21, 0xFC, 0x6C, 0x10, 0x2D, - 0x05, 0xE9, 0x70, 0x08, 0x90, 0x2A, 0x42, 0x7A, 0x99, 0xDD, 0x41, 0xD6, 0x1A, 0x68, 0x42, 0xC1, - 0x18, 0x44, 0xF5, 0x33, 0x84, 0x02, 0xC7, 0x83, 0x1F, 0x9C, 0x25, 0x46, 0x14, 0x30, 0x04, 0x61, - 0x58, 0x24, 0x31, 0x76, 0xE5, 0xA5, 0x50, 0x29, 0x74, 0xAD, 0x0C, 0x68, 0x1C, 0x32, 0x27, 0x0C, - 0x3F, 0x99, 0x67, 0x2E, 0x53, 0xFC, 0xE1, 0x9F, 0xFE, 0x21, 0x47, 0x19, 0x24, 0x12, 0x30, 0x9E, - 0x82, 0x5C, 0x98, 0x85, 0x69, 0x91, 0x49, 0x71, 0x9C, 0x70, 0x97, 0xC7, 0x69, 0x70, 0x28, 0xBF, - 0xFF, 0xFE, 0xA4, 0xE9, 0x62, 0x34, 0x57, 0x01, 0x03, 0x91, 0x12, 0x74, 0x63, 0xCA, 0x00, 0x3B, - 0xFF, 0xFD, 0x0A, 0x0B, 0x8F, 0x02, 0xC5, 0xC5, 0x82, 0x71, 0xE2, 0xA0, 0xFC, 0x4E, 0x25, 0x93, - 0xFF, 0xFF, 0xE3, 0x86, 0x04, 0x61, 0x3A, 0xA9, 0x34, 0xCA, 0x8B, 0xC7, 0x8C, 0x86, 0x11, 0xC0, - 0x00, 0x00, 0x20, 0x5D, 0xC3, 0x40, 0x09, 0x89, 0x24, 0x30, 0x71, 0x80, 0x60, 0x28, 0x54, 0x60, - 0x71, 0xF4, 0x60, 0xC0, 0x28, 0x62, 0x01, 0x32, 0x71, 0xF3, 0x80, 0x62, 0x48, 0xFF, 0xFB, 0x92, - 0x64, 0x0F, 0x07, 0xD4, 0x63, 0x34, 0x4F, 0x43, 0xB9, 0x6B, 0x70, 0x2F, 0xA6, 0x29, 0x80, 0x15, - 0x27, 0x84, 0x51, 0xCC, 0xD1, 0x38, 0x0E, 0xE9, 0xAD, 0xD0, 0xBD, 0x9A, 0x65, 0x48, 0x30, 0x28, - 0x68, 0x26, 0x0A, 0x0C, 0x4C, 0x57, 0x03, 0x47, 0x00, 0x33, 0x04, 0xC4, 0x20, 0xC4, 0x10, 0xBD, - 0x61, 0x5F, 0x96, 0xC3, 0xBC, 0xC7, 0xDF, 0xC8, 0x75, 0x7A, 0x42, 0x63, 0xEC, 0x51, 0xBA, 0x34, - 0x95, 0xD4, 0xF8, 0x88, 0x01, 0x72, 0xDB, 0xB6, 0x75, 0xE3, 0x6B, 0x15, 0x27, 0x82, 0xE8, 0x01, - 0xB0, 0x16, 0x40, 0x12, 0x5C, 0xC2, 0xEA, 0x0C, 0x3C, 0x0A, 0x1A, 0x8B, 0x19, 0x45, 0x81, 0x47, - 0x30, 0x1D, 0x3D, 0x8E, 0x40, 0x01, 0x6C, 0x81, 0x48, 0x48, 0xA0, 0x84, 0x3D, 0x18, 0x14, 0xB8, - 0x8F, 0x7B, 0xD4, 0xA1, 0x0D, 0xFB, 0xB3, 0x63, 0x9E, 0xBF, 0xD2, 0x4B, 0xFF, 0x31, 0x0E, 0x60, - 0x92, 0x94, 0x81, 0x78, 0x4A, 0x91, 0x4E, 0xA1, 0x2C, 0x13, 0xC5, 0xB9, 0xD2, 0x39, 0x35, 0x60, - 0x39, 0xBF, 0xFF, 0xF8, 0xD2, 0xCF, 0x2E, 0x2C, 0x16, 0x20, 0x58, 0xFB, 0x27, 0x4F, 0x23, 0x40, - 0xAA, 0xA3, 0x85, 0xFF, 0xFF, 0x70, 0xDA, 0x98, 0x15, 0x18, 0x2A, 0x30, 0x27, 0x60, 0x98, 0xD2, - 0xFF, 0xFF, 0xFC, 0xE1, 0xB9, 0x25, 0x26, 0x3A, 0x24, 0x9B, 0xA8, 0xE8, 0xF9, 0xAC, 0x93, 0x61, - 0xC8, 0xCA, 0x17, 0x32, 0xCC, 0x80, 0x02, 0x41, 0x20, 0x41, 0x93, 0xA0, 0x08, 0xD2, 0xDA, 0x60, - 0x29, 0x00, 0x6C, 0x8F, 0x36, 0x65, 0xA1, 0x10, 0x40, 0x11, 0x98, 0xA8, 0x4B, 0x18, 0x14, 0x07, - 0x11, 0x00, 0x26, 0x0E, 0x0F, 0xE0, 0x6E, 0xE0, 0x43, 0xC9, 0x26, 0xFD, 0x26, 0x12, 0xD4, 0x73, - 0x69, 0x53, 0x02, 0x2A, 0xC6, 0xF1, 0xB6, 0xB3, 0x1F, 0xA7, 0x48, 0x18, 0x02, 0x5F, 0x18, 0x97, - 0xC7, 0x44, 0x81, 0x18, 0x92, 0x26, 0x7C, 0x61, 0xA5, 0xA0, 0x03, 0x28, 0x19, 0x04, 0x08, 0x6C, - 0xC0, 0x08, 0x2E, 0xE9, 0x83, 0x2C, 0x5D, 0x14, 0x36, 0x35, 0xB0, 0x0D, 0x50, 0xC2, 0x60, 0x26, - 0x60, 0x4C, 0x51, 0x0E, 0xEA, 0xB9, 0x8C, 0x26, 0x02, 0x47, 0x90, 0x84, 0x07, 0x02, 0x8D, 0x33, - 0x04, 0xB6, 0x5A, 0xCF, 0x56, 0x3C, 0x7F, 0xFF, 0xFD, 0x42, 0x4C, 0x1D, 0x47, 0xB8, 0x29, 0x84, - 0x30, 0x9A, 0x25, 0x50, 0x54, 0x86, 0x00, 0x97, 0x63, 0x00, 0x8C, 0x30, 0x85, 0xA0, 0x1A, 0x89, - 0x03, 0x3E, 0x31, 0x21, 0x30, 0x96, 0x4E, 0x0D, 0xA9, 0x61, 0xC1, 0x14, 0x3E, 0x16, 0x86, 0x43, - 0xE6, 0xFA, 0x9E, 0x62, 0xA3, 0x75, 0x2A, 0x17, 0xCA, 0x7A, 0xAD, 0xC7, 0x01, 0x41, 0x87, 0x0F, - 0xAD, 0xFF, 0xFF, 0x4B, 0x22, 0x8D, 0xBE, 0x84, 0xD4, 0x63, 0x14, 0x5A, 0x35, 0x80, 0x00, 0x04, - 0x79, 0x58, 0xC8, 0x0A, 0x33, 0x1C, 0x81, 0x31, 0x18, 0x66, 0x61, 0xF9, 0xEA, 0x0E, 0x71, 0x0C, - 0x77, 0x0A, 0x4D, 0xAA, 0x55, 0xCF, 0x00, 0x0D, 0x87, 0x01, 0xA3, 0x10, 0xC9, 0xA3, 0x2C, 0xFF, - 0xFB, 0x92, 0x64, 0x11, 0x05, 0x34, 0x95, 0x34, 0x4E, 0x2B, 0xBA, 0x6B, 0x70, 0x32, 0x26, 0x79, - 0x9D, 0x1C, 0xC5, 0xD0, 0x50, 0xE0, 0xCF, 0x3D, 0x0E, 0xE6, 0x0D, 0xC8, 0xBE, 0x19, 0x67, 0xB8, - 0x80, 0x0B, 0x80, 0x82, 0x01, 0xD0, 0x20, 0xC3, 0x11, 0xE0, 0xD0, 0x92, 0x10, 0x94, 0x33, 0x70, - 0x0B, 0xD6, 0xE1, 0x20, 0x8D, 0x4B, 0x63, 0x68, 0x73, 0x81, 0x5E, 0x0B, 0x5E, 0xC6, 0x92, 0x49, - 0xE4, 0x5D, 0x89, 0xAE, 0xDE, 0xCB, 0x60, 0x01, 0x00, 0x45, 0xDE, 0x45, 0x6C, 0x00, 0x00, 0xD1, - 0xC8, 0x31, 0x46, 0xCA, 0x09, 0xA2, 0x08, 0x63, 0xC5, 0x56, 0x31, 0x61, 0x00, 0x26, 0xD7, 0x79, - 0x0A, 0x33, 0x58, 0x41, 0x42, 0x8C, 0x01, 0xF2, 0x85, 0xED, 0xC1, 0xDB, 0x03, 0x28, 0x64, 0x2C, - 0x45, 0xFD, 0x4E, 0xD4, 0xAA, 0x4E, 0x06, 0x56, 0xAC, 0x32, 0x5C, 0x5F, 0xFF, 0xFF, 0x93, 0x84, - 0xFC, 0x1E, 0xC0, 0x01, 0xE0, 0x90, 0x81, 0x9E, 0x58, 0xEB, 0x31, 0x10, 0x22, 0x12, 0x23, 0xD8, - 0x24, 0x42, 0x74, 0x90, 0x08, 0x06, 0x2A, 0x00, 0x00, 0x31, 0x00, 0x04, 0x61, 0x12, 0xFA, 0x31, - 0x8B, 0xF3, 0x15, 0xAE, 0x45, 0xAA, 0x7C, 0xB9, 0x26, 0x48, 0xC9, 0x7A, 0xAF, 0xF0, 0x81, 0x94, - 0x44, 0x2D, 0xE5, 0x45, 0x87, 0xA6, 0x99, 0xA1, 0x67, 0xD1, 0x33, 0xCF, 0xF6, 0xFF, 0xFF, 0xFF, - 0x2F, 0xF5, 0xC4, 0xC0, 0xE7, 0x9F, 0x00, 0x02, 0xFB, 0x8A, 0x80, 0x26, 0x03, 0x13, 0xA6, 0x2A, - 0x01, 0x84, 0x20, 0x69, 0x86, 0x06, 0xA9, 0x8B, 0x41, 0x41, 0x8A, 0x80, 0x29, 0x88, 0xC5, 0x91, - 0xE8, 0x04, 0xE1, 0x85, 0x80, 0x18, 0xE8, 0x98, 0x6A, 0x40, 0x50, 0x34, 0x06, 0x03, 0x00, 0x21, - 0x26, 0x57, 0xD8, 0x84, 0x31, 0x66, 0xAE, 0xA1, 0xEA, 0xB8, 0x84, 0x39, 0x2F, 0xA4, 0x23, 0xF7, - 0x40, 0xDC, 0xCB, 0x78, 0xD3, 0xE5, 0xB2, 0xD9, 0xC8, 0x7B, 0x4D, 0x64, 0x29, 0x19, 0xF9, 0xA1, - 0x8C, 0x21, 0x82, 0xF0, 0x65, 0x40, 0xA0, 0x05, 0x02, 0x76, 0x9A, 0x52, 0xD1, 0x1A, 0x78, 0x39, - 0xD6, 0x7A, 0x55, 0x05, 0x1B, 0xC0, 0x03, 0x8A, 0x8A, 0xB0, 0x0D, 0x68, 0x2E, 0x58, 0xD0, 0x65, - 0xD6, 0x2A, 0x82, 0x95, 0xF0, 0xF4, 0xB6, 0x92, 0x3B, 0xD7, 0xFF, 0xFF, 0xA1, 0x48, 0x6E, 0x86, - 0x11, 0x11, 0x51, 0xA0, 0x74, 0xBA, 0x95, 0x87, 0x0A, 0x52, 0x1D, 0x32, 0x90, 0x00, 0x0C, 0x16, - 0x00, 0x00, 0x20, 0x60, 0x8B, 0x91, 0x5D, 0x03, 0xE2, 0x6E, 0xD7, 0xF8, 0x47, 0xB4, 0x19, 0xC5, - 0x4F, 0x2F, 0x36, 0x51, 0x97, 0x37, 0xFF, 0xA5, 0x20, 0xC4, 0x40, 0xE6, 0x12, 0x6C, 0x51, 0x4B, - 0x19, 0x64, 0x8D, 0xBA, 0xB5, 0xB8, 0x9B, 0xFF, 0x52, 0x37, 0xD9, 0x22, 0xD5, 0x80, 0x00, 0x03, - 0xC2, 0xCD, 0xCC, 0x38, 0x24, 0x4C, 0xCC, 0x0B, 0x0C, 0x00, 0x09, 0x0C, 0x7E, 0x1A, 0x43, 0x3B, - 0xD3, 0x0A, 0x41, 0x63, 0x36, 0xD0, 0x73, 0x6B, 0xA7, 0x13, 0x14, 0xC4, 0xA3, 0x01, 0x05, 0x83, - 0x43, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x07, 0x34, 0xA1, 0x34, 0xCD, 0xAB, 0xB9, 0x7B, 0x70, 0x2E, - 0x83, 0xFA, 0x0F, 0x2C, 0x43, 0x4E, 0x11, 0x28, 0xD5, 0x38, 0x0E, 0xE6, 0x2D, 0xC0, 0xC7, 0x99, - 0xE6, 0xD0, 0x27, 0x94, 0xC1, 0xDF, 0x33, 0x15, 0x40, 0x31, 0x80, 0xA8, 0x79, 0x8B, 0x46, 0x50, - 0x60, 0x03, 0x5A, 0x9D, 0x50, 0xB0, 0xAB, 0x36, 0xB9, 0x7D, 0x57, 0xEF, 0xBC, 0x7B, 0x60, 0x09, - 0xA4, 0xA9, 0x20, 0x5C, 0x13, 0x1F, 0x53, 0x0C, 0x0D, 0x01, 0x60, 0x54, 0x8C, 0x48, 0x46, 0xAB, - 0x42, 0x90, 0x23, 0xA8, 0x4D, 0x4E, 0x76, 0x1C, 0xA3, 0xC2, 0x24, 0x4D, 0xC4, 0x46, 0xA2, 0x49, - 0xD1, 0x75, 0x4D, 0x31, 0xDC, 0x35, 0x2D, 0x2F, 0x94, 0x0C, 0x0E, 0x14, 0x22, 0x35, 0x9C, 0xCB, - 0x91, 0x1D, 0xF9, 0x65, 0x30, 0xCC, 0xFE, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE8, 0xAF, 0x45, - 0xB9, 0x8B, 0x78, 0x8E, 0x80, 0xC0, 0x24, 0xA1, 0x52, 0x86, 0x53, 0x3B, 0x31, 0xB3, 0x52, 0x7A, - 0x07, 0xD0, 0x9C, 0x17, 0x3B, 0x80, 0x01, 0x82, 0xC8, 0x00, 0x00, 0x00, 0x60, 0x00, 0x14, 0xA2, - 0xF9, 0xAF, 0xC8, 0xAC, 0xF9, 0xA9, 0xD0, 0xE2, 0x9D, 0x4B, 0x52, 0x2F, 0xB2, 0xB6, 0xFF, 0x03, - 0x64, 0x0B, 0x36, 0xA2, 0xEA, 0x39, 0x39, 0x78, 0xC2, 0xD4, 0x28, 0xC1, 0x9B, 0xBF, 0xEA, 0x3E, - 0x13, 0xCF, 0x92, 0x54, 0x02, 0xC1, 0xC0, 0x00, 0x51, 0x9B, 0x00, 0xB9, 0x80, 0x81, 0x30, 0x04, - 0x64, 0x31, 0x20, 0xDF, 0x30, 0x60, 0x15, 0x32, 0x50, 0x4F, 0x3C, 0xB5, 0xE4, 0x31, 0x00, 0x35, - 0x30, 0x9C, 0x32, 0x33, 0xD2, 0x10, 0x14, 0x06, 0x12, 0x00, 0x98, 0x36, 0x2E, 0x9A, 0xE0, 0xC0, - 0x04, 0x93, 0xA6, 0x25, 0x1C, 0x88, 0x28, 0x93, 0x55, 0x5F, 0x99, 0x37, 0x58, 0xDC, 0xF4, 0x6C, - 0xA1, 0x67, 0x1F, 0xD0, 0xC1, 0x38, 0x2D, 0xA4, 0xBB, 0x4D, 0x1D, 0x18, 0xC1, 0xC9, 0x2D, 0xE6, - 0xD1, 0x58, 0x22, 0xB6, 0xEE, 0xC0, 0x92, 0xC1, 0x27, 0x94, 0xB8, 0x00, 0x22, 0x5C, 0x28, 0x12, - 0xEA, 0x94, 0x41, 0x8F, 0xB3, 0x90, 0xD9, 0x9F, 0xD5, 0x0A, 0x58, 0xCB, 0xB5, 0x7A, 0xC5, 0x29, - 0xAD, 0x37, 0xFF, 0xFC, 0x73, 0x48, 0x69, 0x36, 0x1F, 0x29, 0x3C, 0x08, 0x40, 0x1B, 0xE2, 0x97, - 0x1F, 0x63, 0xAC, 0xD4, 0xBF, 0x9C, 0x28, 0x8C, 0x32, 0x2C, 0x38, 0xCB, 0x6C, 0x00, 0x22, 0x02, - 0x00, 0x18, 0xCF, 0x33, 0xDC, 0x76, 0x9E, 0x56, 0xFA, 0x00, 0x60, 0xA5, 0x22, 0x89, 0x19, 0xE8, - 0x7E, 0xAD, 0x16, 0x79, 0x87, 0x4D, 0x43, 0x65, 0x7C, 0x3A, 0x52, 0xB9, 0x67, 0x16, 0x18, 0xE5, - 0x40, 0x6F, 0xFF, 0xFF, 0x51, 0x62, 0xA0, 0xB1, 0xDC, 0xA4, 0x14, 0x97, 0xCC, 0x36, 0x25, 0x00, - 0x80, 0x0B, 0x8A, 0xCA, 0x61, 0x61, 0xB0, 0x63, 0x70, 0x56, 0x60, 0x68, 0x74, 0x34, 0x7B, 0x9A, - 0xD2, 0x3D, 0x18, 0x2E, 0x0F, 0x98, 0xDA, 0x3A, 0x1C, 0xC1, 0x25, 0x98, 0xDE, 0x0D, 0x98, 0x34, - 0x05, 0x19, 0xFE, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x0D, 0xF4, 0x77, 0x34, 0xCE, 0x13, 0xB9, 0x6B, - 0x74, 0x2E, 0xE6, 0x99, 0x55, 0x1C, 0x08, 0xE0, 0x91, 0xAC, 0xD1, 0x38, 0x4E, 0xE6, 0x4D, 0xC8, - 0xC1, 0x1A, 0x65, 0x00, 0x70, 0x27, 0x80, 0x36, 0x1A, 0x14, 0x00, 0x0F, 0x04, 0xE3, 0x2B, 0x81, - 0xCF, 0x53, 0x54, 0x64, 0x26, 0x6E, 0x79, 0x78, 0x81, 0xCC, 0x6F, 0x6A, 0xB0, 0x39, 0xF9, 0x4B, - 0xF7, 0x3F, 0x25, 0x14, 0x3D, 0x03, 0xE5, 0xD0, 0x42, 0x50, 0xE4, 0x9B, 0xAC, 0xF2, 0x52, 0x32, - 0x40, 0x3C, 0x27, 0x2D, 0xA2, 0x90, 0x30, 0xF3, 0x30, 0x24, 0xC2, 0x4C, 0xC7, 0xE9, 0x13, 0x8E, - 0x00, 0x95, 0xC8, 0x58, 0x14, 0xFB, 0x95, 0xCA, 0x18, 0x34, 0x41, 0xA5, 0x08, 0xC8, 0x8A, 0x4A, - 0xD0, 0x4C, 0xA7, 0x19, 0xFA, 0x3F, 0xFF, 0xF1, 0x02, 0x13, 0x32, 0x59, 0xC4, 0xB8, 0x08, 0xF0, - 0x93, 0x04, 0xE8, 0x5C, 0x10, 0x70, 0xB8, 0x12, 0xC8, 0x30, 0xF7, 0x20, 0x0C, 0x30, 0x29, 0xA0, - 0x3C, 0x26, 0x40, 0x00, 0x04, 0x3B, 0x67, 0x9C, 0x3A, 0xED, 0xF8, 0xE1, 0x65, 0x71, 0x72, 0x50, - 0x70, 0xD1, 0x50, 0x6C, 0xF9, 0xFA, 0xA9, 0x79, 0x51, 0x8A, 0xFF, 0xF5, 0x30, 0xC2, 0xA3, 0xE3, - 0xE0, 0xF7, 0x1E, 0x46, 0xFF, 0x24, 0x56, 0xB6, 0xFB, 0x18, 0x0E, 0xF1, 0x57, 0xE3, 0x0A, 0x6B, - 0x38, 0x03, 0x5D, 0x48, 0x05, 0x31, 0x5C, 0x26, 0x33, 0xCC, 0x0B, 0x16, 0x07, 0xCC, 0x8D, 0x00, - 0x4D, 0x66, 0x14, 0x8B, 0x22, 0x61, 0x50, 0x92, 0x67, 0x3F, 0x28, 0x60, 0x58, 0x08, 0x60, 0x40, - 0x6A, 0x61, 0xFC, 0x06, 0x65, 0xF0, 0x26, 0x44, 0x13, 0x0C, 0xEA, 0x81, 0xCC, 0x2A, 0x36, 0x5F, - 0xE9, 0x64, 0xA0, 0xC1, 0x66, 0xFF, 0x5D, 0x0B, 0x56, 0xDD, 0x39, 0x44, 0xA0, 0x90, 0x11, 0x25, - 0xAD, 0xB7, 0x74, 0xE7, 0x94, 0xB8, 0x42, 0xE4, 0x30, 0x47, 0x0C, 0xD0, 0x74, 0x99, 0x37, 0x05, - 0x39, 0x85, 0x93, 0xA6, 0x19, 0x0C, 0x69, 0x4B, 0xA4, 0x20, 0x1B, 0xC6, 0xDF, 0x76, 0x69, 0x5B, - 0xEB, 0x63, 0xA6, 0xA6, 0x7C, 0x30, 0xA1, 0xC3, 0xC0, 0x5F, 0x6B, 0x6A, 0xB2, 0x93, 0x6A, 0xFF, - 0xFF, 0x40, 0xA2, 0x18, 0x48, 0xC8, 0x9B, 0x04, 0x00, 0x05, 0xC8, 0x43, 0x85, 0x74, 0x14, 0x82, - 0x22, 0x45, 0x03, 0xC4, 0x79, 0x84, 0x84, 0xB8, 0x44, 0x80, 0xAA, 0x03, 0x63, 0x8A, 0x99, 0xFF, - 0xFE, 0x72, 0x14, 0x30, 0xB1, 0x1B, 0x83, 0xF3, 0x47, 0x8E, 0x1A, 0x28, 0x5C, 0x0B, 0xB9, 0x10, - 0x07, 0x04, 0x14, 0x03, 0xC5, 0xDF, 0xFD, 0x96, 0x0F, 0xC6, 0xE2, 0x91, 0xB8, 0xDC, 0x97, 0xFF, - 0xFD, 0x91, 0xBE, 0xE7, 0xF8, 0x53, 0x16, 0xDE, 0x09, 0xEE, 0xBB, 0x53, 0x91, 0x43, 0xCA, 0x80, - 0x00, 0x00, 0x03, 0x00, 0x1A, 0xCA, 0xD0, 0x31, 0x08, 0x4D, 0x34, 0xE4, 0x4A, 0x15, 0x13, 0x4C, - 0x3F, 0x08, 0x0D, 0x8F, 0x3C, 0x4C, 0x3B, 0x0F, 0xCC, 0xA7, 0x39, 0x8E, 0x2F, 0xC1, 0xC0, 0x4D, - 0xC0, 0xD0, 0xDE, 0x62, 0x15, 0xFF, 0xFB, 0x92, 0x64, 0x13, 0x05, 0xB4, 0xB2, 0x34, 0xCD, 0xCB, - 0xB9, 0x9B, 0xE0, 0x31, 0xA6, 0x99, 0x78, 0x15, 0x87, 0x92, 0x11, 0xC4, 0xD5, 0x38, 0x0D, 0x77, - 0x25, 0x00, 0xC1, 0x1A, 0xA5, 0xD0, 0x54, 0xA9, 0xD8, 0x72, 0x63, 0x08, 0x12, 0x5E, 0xC0, 0xB8, - 0xDE, 0x60, 0x90, 0x08, 0x8C, 0xF1, 0xD0, 0xCC, 0x1A, 0x8A, 0x2F, 0x1A, 0xC7, 0x3E, 0x72, 0x85, - 0xB5, 0x26, 0xF8, 0xC3, 0x56, 0xEA, 0x8E, 0x89, 0x21, 0x28, 0x19, 0x24, 0x2E, 0xC3, 0x02, 0x56, - 0xC1, 0x2E, 0xD0, 0xB5, 0xCA, 0x10, 0xB0, 0x45, 0x75, 0x94, 0x59, 0x1A, 0xAA, 0x56, 0x9A, 0x22, - 0x46, 0xBA, 0x69, 0x2C, 0x79, 0xA1, 0x2D, 0xB0, 0x93, 0xEC, 0x5E, 0x88, 0xA8, 0x79, 0x37, 0x54, - 0xE4, 0x80, 0x2D, 0x5A, 0xD0, 0x29, 0x10, 0x70, 0x77, 0xAF, 0xFF, 0xFD, 0x22, 0x54, 0x83, 0x0D, - 0xE2, 0x6C, 0x10, 0xD8, 0x04, 0x28, 0x75, 0x09, 0xE8, 0x2C, 0x4C, 0xA4, 0x7C, 0x80, 0x9D, 0x28, - 0x06, 0x23, 0x2B, 0x18, 0x87, 0x10, 0x03, 0x14, 0x1E, 0x00, 0x00, 0xC0, 0x00, 0x03, 0x11, 0xBF, - 0xFE, 0x98, 0xF2, 0x89, 0xF0, 0xED, 0xFB, 0xDD, 0x4E, 0x76, 0x92, 0x46, 0x83, 0x93, 0xD5, 0x05, - 0xA1, 0xDF, 0xF9, 0x41, 0xDC, 0x88, 0x68, 0xA9, 0x10, 0x7D, 0xE7, 0xBF, 0xFF, 0xFF, 0x8D, 0x4B, - 0x9C, 0x98, 0x12, 0x3F, 0x82, 0xD7, 0x8A, 0x9D, 0x46, 0x0A, 0x1E, 0xB9, 0x4B, 0x03, 0x0D, 0xEF, - 0xB3, 0xD4, 0x90, 0xAA, 0x94, 0xCA, 0x2F, 0x33, 0xD1, 0x42, 0x06, 0x92, 0x26, 0x27, 0x85, 0x27, - 0x25, 0x3A, 0x26, 0x61, 0x81, 0xA0, 0x21, 0x94, 0xC6, 0x24, 0xFC, 0xCF, 0x30, 0x84, 0x98, 0x30, - 0x30, 0x2C, 0x67, 0x16, 0x23, 0x53, 0x7D, 0x84, 0x27, 0xBB, 0xC8, 0xC8, 0x8D, 0xD4, 0x57, 0xFD, - 0x21, 0x79, 0xF9, 0x93, 0xF0, 0xAB, 0x2E, 0x17, 0xD0, 0x7B, 0x47, 0xA5, 0x7D, 0x9C, 0xC4, 0xC4, - 0xCA, 0xA2, 0x1C, 0x5C, 0xA8, 0x5B, 0xA0, 0x62, 0x4D, 0x1E, 0x9E, 0x4B, 0xE6, 0xA7, 0x7E, 0x02, - 0x8B, 0xAC, 0x23, 0x94, 0x79, 0x12, 0xFE, 0xDA, 0x53, 0x75, 0x6A, 0x97, 0x0C, 0x0A, 0x24, 0xB6, - 0x2C, 0x29, 0x57, 0x65, 0x1C, 0x2E, 0x2C, 0xFF, 0x2D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xEA, 0xAD, 0x5A, 0x5D, 0x05, 0x88, 0x13, 0x56, 0xC4, 0x0E, 0x25, 0x15, 0xAC, 0x3B, 0xB9, - 0x43, 0x58, 0xB9, 0x1D, 0x15, 0x21, 0x38, 0x24, 0x1C, 0x14, 0x00, 0x70, 0x0C, 0x8D, 0xFF, 0xEC, - 0xDC, 0xAB, 0x6B, 0xEF, 0x48, 0x51, 0x0B, 0x9C, 0x0A, 0x17, 0x0D, 0xF1, 0xA0, 0x48, 0xF3, 0x9B, - 0xEA, 0x7E, 0x79, 0xF7, 0x04, 0xDE, 0xEE, 0xCA, 0xAC, 0x98, 0xB8, 0x58, 0x6F, 0xFF, 0xFE, 0x44, - 0x72, 0x9D, 0x5A, 0x68, 0x77, 0xAB, 0x88, 0x31, 0x6D, 0xAA, 0x87, 0x52, 0x18, 0xC4, 0xE0, 0x94, - 0xCE, 0x60, 0x04, 0xC0, 0x80, 0x0C, 0xC0, 0xA0, 0x08, 0xC3, 0xF4, 0xD4, 0x1C, 0x00, 0x08, 0x80, - 0x03, 0x1B, 0x77, 0x03, 0x0D, 0x80, 0x43, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x87, 0x94, 0x4F, 0x34, - 0xCE, 0x83, 0xBA, 0xA3, 0x70, 0x32, 0x26, 0x99, 0xAC, 0x18, 0x05, 0x18, 0x11, 0x38, 0xD3, 0x3D, - 0x0E, 0xE9, 0xAF, 0x80, 0xB1, 0x9A, 0x66, 0x50, 0x60, 0x14, 0x62, 0x02, 0xC0, 0xA3, 0x1A, 0x10, - 0xE3, 0x29, 0x41, 0xE1, 0xA0, 0x40, 0x1B, 0xAC, 0x4D, 0x43, 0x6E, 0x94, 0xE1, 0x0B, 0xA0, 0x47, - 0x80, 0xCC, 0x1C, 0x91, 0xBC, 0x0A, 0x11, 0x07, 0xD2, 0xB4, 0xF4, 0x59, 0xE8, 0xE0, 0xC2, 0x24, - 0xB1, 0x02, 0xF2, 0x21, 0x1C, 0x45, 0x39, 0xCE, 0xF9, 0xC4, 0xE3, 0x8A, 0x89, 0x2B, 0x6F, 0x68, - 0x56, 0xFA, 0xAE, 0xA5, 0xAC, 0x84, 0x4E, 0x1B, 0x62, 0x09, 0x1F, 0x22, 0x67, 0xCA, 0x0D, 0x3F, - 0x2F, 0x18, 0x1C, 0xDB, 0x65, 0x0C, 0x4B, 0xE7, 0xE0, 0xC7, 0x9A, 0x18, 0x8E, 0x9F, 0xFF, 0xFF, - 0xC4, 0x24, 0x28, 0x8C, 0xD0, 0x10, 0x40, 0x48, 0x91, 0x02, 0x0A, 0x26, 0x46, 0x3C, 0x81, 0x08, - 0x2E, 0x81, 0x0D, 0x02, 0x82, 0xC5, 0xE1, 0x22, 0x00, 0x00, 0x0A, 0x00, 0x00, 0xC0, 0x03, 0x41, - 0x09, 0xF5, 0x6C, 0x6A, 0x15, 0xE8, 0x12, 0x17, 0x95, 0x8C, 0x12, 0x06, 0x17, 0x10, 0x50, 0x27, - 0xF0, 0xE6, 0x16, 0x6A, 0xA6, 0x41, 0xF1, 0x17, 0x45, 0xDC, 0x3A, 0x3A, 0xAF, 0xFF, 0xFF, 0x13, - 0x13, 0x18, 0x44, 0x89, 0xB7, 0xA0, 0xA4, 0x55, 0xCC, 0x1D, 0xC0, 0x08, 0x21, 0x3D, 0xCC, 0x05, - 0x36, 0x0C, 0x1E, 0x0A, 0x44, 0x40, 0x00, 0xA8, 0xA2, 0x66, 0x99, 0x9C, 0x2C, 0x1F, 0x98, 0x92, - 0x09, 0x1A, 0x37, 0x6D, 0x80, 0x88, 0x91, 0xC0, 0x60, 0xC4, 0x34, 0x98, 0x38, 0x18, 0x4C, 0x90, - 0x29, 0x16, 0x2C, 0x52, 0x40, 0xC5, 0x51, 0xA9, 0xF5, 0x15, 0x6E, 0x42, 0x80, 0x6A, 0x5A, 0x54, - 0xD9, 0xC4, 0xC8, 0x43, 0xC3, 0xB4, 0xA4, 0x81, 0x08, 0x84, 0xD8, 0x73, 0x8A, 0x0B, 0x4A, 0xCB, - 0x28, 0x7A, 0x02, 0x45, 0x56, 0x08, 0x22, 0xAB, 0xE4, 0xF8, 0x81, 0x47, 0xC2, 0xE6, 0x90, 0xC1, - 0x75, 0x17, 0xDC, 0x2A, 0x2C, 0x0D, 0xAA, 0x75, 0xFD, 0x22, 0x33, 0x29, 0xC5, 0x14, 0xE7, 0x25, - 0x2C, 0x4A, 0xD4, 0xCA, 0xF8, 0x7C, 0xE2, 0x77, 0x4B, 0x7F, 0xFF, 0xD3, 0x30, 0x12, 0x72, 0x68, - 0xEF, 0x02, 0x0E, 0x12, 0xC1, 0x80, 0x26, 0x82, 0xD8, 0xA8, 0xA7, 0xA2, 0x17, 0xA2, 0x78, 0xC3, - 0x82, 0x94, 0x62, 0x78, 0x30, 0x05, 0x9C, 0x15, 0xEB, 0x91, 0xC9, 0xB9, 0x46, 0x55, 0xA2, 0x61, - 0xF1, 0x85, 0x08, 0x0B, 0xFF, 0x0F, 0xE2, 0x23, 0xBE, 0x30, 0x7C, 0x29, 0xD1, 0xA8, 0x24, 0x45, - 0x10, 0x14, 0xFF, 0xFF, 0xE5, 0x05, 0x71, 0x26, 0x2C, 0x4C, 0xF4, 0x42, 0xA0, 0x71, 0x08, 0x03, - 0x55, 0x5D, 0xC2, 0x00, 0x14, 0xC3, 0x50, 0x74, 0xD1, 0xB0, 0x8C, 0x0C, 0x09, 0x05, 0x01, 0x53, - 0x75, 0x82, 0xD0, 0x10, 0xF2, 0x63, 0xB0, 0x2E, 0x73, 0xC7, 0x40, 0x9F, 0x80, 0x40, 0x54, 0xC9, - 0x54, 0xC4, 0xC3, 0x60, 0x44, 0xC0, 0xB0, 0x1C, 0xC2, 0xFF, 0xFB, 0x92, 0x64, 0x14, 0x0F, 0xD4, - 0xC8, 0x34, 0x4D, 0x83, 0xBB, 0x9B, 0xE0, 0x30, 0x26, 0x89, 0x78, 0x18, 0x0D, 0x1A, 0x11, 0xE8, - 0xD1, 0x38, 0x0E, 0xEA, 0x6F, 0x80, 0xBF, 0x1A, 0x24, 0xC0, 0x60, 0x28, 0x30, 0x15, 0x5C, 0xC0, - 0x10, 0x34, 0x04, 0x08, 0x10, 0x12, 0xA1, 0x3A, 0x05, 0x80, 0x06, 0xA6, 0xA4, 0xF2, 0x92, 0x22, - 0x89, 0x04, 0x40, 0xC2, 0x06, 0xA8, 0x1D, 0x13, 0x11, 0x2D, 0x42, 0x16, 0x7C, 0xF9, 0x09, 0x01, - 0x50, 0x05, 0x99, 0x80, 0x67, 0xAC, 0x40, 0x46, 0x2C, 0x0E, 0x8B, 0x6B, 0x0C, 0xCC, 0xC1, 0x03, - 0x1E, 0xAB, 0x20, 0x21, 0xA6, 0x7A, 0x91, 0x46, 0x2C, 0x28, 0x50, 0x7F, 0x0E, 0x8C, 0x8E, 0x89, - 0x1A, 0x4D, 0x23, 0xB8, 0xF2, 0x14, 0xF4, 0xCA, 0xA0, 0x9C, 0x8E, 0x17, 0xAE, 0x7B, 0xE6, 0x88, - 0x57, 0xFF, 0xFE, 0x4A, 0x8A, 0x99, 0x5C, 0xE8, 0x18, 0x10, 0x04, 0xA4, 0x40, 0x43, 0x5E, 0x0C, - 0xA1, 0x16, 0x15, 0x81, 0xB5, 0x1D, 0x03, 0x9A, 0x53, 0x2E, 0x86, 0xA0, 0x23, 0x76, 0x20, 0x00, - 0x01, 0x00, 0x04, 0x0E, 0xF9, 0xCA, 0x9A, 0x48, 0x12, 0x66, 0x54, 0x70, 0xE8, 0x37, 0xB0, 0x9A, - 0x11, 0xCD, 0xD1, 0xFF, 0xFF, 0x49, 0x2E, 0x70, 0xA5, 0x48, 0xA4, 0x56, 0xE5, 0xF3, 0xDF, 0xFF, - 0xFA, 0xD4, 0x3B, 0x49, 0x15, 0x8C, 0xC7, 0xE3, 0xEA, 0x55, 0x34, 0xE1, 0x89, 0xBB, 0x4A, 0xE0, - 0x43, 0x06, 0x00, 0x43, 0x43, 0xC0, 0x64, 0x57, 0x00, 0x89, 0x86, 0x5F, 0x98, 0x63, 0xC2, 0x69, - 0x93, 0xA1, 0x19, 0xC5, 0x3A, 0x38, 0x28, 0x7A, 0x1A, 0x05, 0x8C, 0xAC, 0x0F, 0x47, 0x8F, 0xB1, - 0x40, 0x2C, 0xC3, 0x83, 0x24, 0xC7, 0xB0, 0x3D, 0x50, 0x92, 0xA5, 0x24, 0x03, 0x1D, 0x15, 0x0E, - 0x19, 0x69, 0xCB, 0xDA, 0x12, 0xF2, 0xA4, 0x31, 0xA1, 0xDE, 0xC7, 0xFC, 0xC8, 0x01, 0x62, 0xEB, - 0xE0, 0x1A, 0x11, 0xA0, 0x52, 0x98, 0x1B, 0x02, 0xFE, 0x59, 0x02, 0xFF, 0x23, 0x1F, 0x55, 0x80, - 0x18, 0x20, 0xAF, 0xDD, 0xF3, 0x0C, 0x1D, 0xD7, 0x47, 0x03, 0x2B, 0x91, 0x11, 0x1E, 0xF0, 0xB0, - 0xC1, 0x61, 0xB9, 0xA6, 0x4A, 0x07, 0x69, 0xE0, 0x62, 0xB4, 0x0F, 0x02, 0xB8, 0x68, 0x1C, 0x74, - 0xC9, 0x7F, 0xFF, 0xF3, 0xA2, 0x80, 0x45, 0x30, 0xB5, 0xB1, 0xA0, 0x35, 0x40, 0xAD, 0x42, 0xE7, - 0x49, 0xA1, 0xD4, 0x44, 0x96, 0x2F, 0x8B, 0xEB, 0x16, 0xA0, 0x58, 0x22, 0xAD, 0x6C, 0x15, 0xC7, - 0xC6, 0xA0, 0x5D, 0x0A, 0x40, 0x45, 0x9A, 0x60, 0x37, 0x05, 0x32, 0x08, 0xA1, 0x14, 0x59, 0xFF, - 0xFF, 0xFE, 0x87, 0xB5, 0x85, 0xC4, 0xE2, 0xA8, 0xF5, 0x1B, 0xFF, 0xF8, 0x0F, 0x8A, 0x4A, 0x0B, - 0x42, 0x58, 0xD8, 0xE2, 0x6D, 0xA7, 0x08, 0xB1, 0x08, 0x23, 0x05, 0x01, 0x3B, 0x2A, 0x88, 0xB8, - 0x06, 0x21, 0x97, 0x66, 0x04, 0x07, 0x04, 0x80, 0x01, 0x80, 0x23, 0x59, 0x94, 0xE6, 0xE0, 0x08, - 0xD3, 0x30, 0x68, 0x6E, 0x37, 0x8A, 0xEC, 0x08, 0x1E, 0xCC, 0x0C, 0xFF, 0xFB, 0x92, 0x64, 0x0E, - 0x85, 0xD4, 0x6E, 0x34, 0x4E, 0x83, 0xBA, 0x9B, 0xE0, 0x30, 0x86, 0x89, 0x27, 0x1C, 0xCD, 0xD0, - 0x11, 0x78, 0xD3, 0x3B, 0x0E, 0xEE, 0x4F, 0x80, 0xB4, 0x9A, 0x25, 0x0C, 0x60, 0x34, 0x30, 0x05, - 0x8C, 0x3B, 0x4C, 0x84, 0x40, 0x71, 0x74, 0xCC, 0x5C, 0x30, 0x86, 0x8E, 0x70, 0x70, 0x10, 0x30, - 0x7D, 0x0E, 0xB1, 0xB2, 0x51, 0x66, 0x48, 0x04, 0xAE, 0x56, 0xB9, 0xA5, 0xF8, 0x98, 0x00, 0x52, - 0x19, 0x40, 0x35, 0x82, 0xE1, 0x6E, 0x8D, 0xFA, 0xB4, 0xC4, 0x42, 0xE7, 0x05, 0xFE, 0x20, 0x3C, - 0x80, 0x78, 0xF1, 0x67, 0xED, 0xF0, 0x1A, 0x4F, 0xAA, 0x60, 0x08, 0x48, 0xC2, 0x4B, 0x98, 0x39, - 0xAE, 0xCC, 0x78, 0x64, 0xB4, 0x6E, 0x3C, 0xB6, 0xD2, 0x0F, 0x6C, 0xFA, 0xCC, 0xC4, 0x5D, 0x21, - 0x5F, 0xFC, 0xDF, 0xC2, 0xB3, 0x7F, 0xFF, 0x44, 0x59, 0x66, 0x02, 0xFC, 0x05, 0x92, 0x39, 0xA4, - 0x68, 0x0E, 0xE8, 0x5C, 0x63, 0x25, 0xA9, 0xC8, 0xE1, 0xEC, 0xF1, 0x1C, 0x0B, 0x18, 0x92, 0x4C, - 0x04, 0x01, 0x00, 0x00, 0x00, 0x41, 0x7F, 0xFF, 0x7C, 0x70, 0x16, 0x04, 0x8D, 0x53, 0x52, 0xFF, - 0x9D, 0xFF, 0xFE, 0x96, 0xE2, 0x00, 0x19, 0x67, 0xEB, 0xA9, 0x3D, 0x16, 0x5E, 0x26, 0xFF, 0xFF, - 0x85, 0x68, 0xB7, 0x59, 0x91, 0xA1, 0xBB, 0xFA, 0x96, 0x38, 0x4B, 0xA1, 0x3B, 0x0D, 0x01, 0x19, - 0xA0, 0x04, 0x2E, 0x0A, 0x0F, 0x18, 0xA8, 0x2B, 0x99, 0xDC, 0x0E, 0x20, 0xD8, 0x34, 0x0C, 0x35, - 0x60, 0x21, 0x32, 0x20, 0x16, 0x30, 0x40, 0x28, 0x36, 0xAE, 0xC9, 0x7F, 0x13, 0xD4, 0xC5, 0xD3, - 0xBC, 0xC2, 0x40, 0x1C, 0x74, 0x06, 0x1C, 0x55, 0x0C, 0x0A, 0x06, 0x82, 0xE0, 0x58, 0xA8, 0xF8, - 0xD0, 0x03, 0xE6, 0xAA, 0x24, 0xCB, 0x90, 0x89, 0x41, 0x30, 0x46, 0x15, 0x81, 0x21, 0xF9, 0x41, - 0x26, 0x02, 0x32, 0xBF, 0x5A, 0x31, 0x60, 0x15, 0xA6, 0xBB, 0x09, 0x92, 0x57, 0x00, 0xF8, 0x05, - 0x40, 0xCC, 0x70, 0x1A, 0xCF, 0x0B, 0x99, 0x37, 0x29, 0x2E, 0xEC, 0xCC, 0x3A, 0x02, 0x44, 0x22, - 0x0A, 0x79, 0x07, 0x40, 0x9B, 0xFC, 0xD9, 0xDA, 0x6C, 0xED, 0xE0, 0x97, 0xE7, 0x2C, 0x1E, 0x06, - 0x90, 0xDF, 0x7B, 0x92, 0xFF, 0xFF, 0x40, 0x59, 0x0B, 0x2C, 0x80, 0x86, 0x2C, 0x17, 0x84, 0x78, - 0x0C, 0x92, 0x76, 0xCA, 0x92, 0x48, 0x0E, 0x91, 0x2C, 0x20, 0xE5, 0x77, 0xAD, 0x80, 0x01, 0xD8, - 0xD4, 0x4B, 0x8D, 0x2D, 0x58, 0xC6, 0x6F, 0x41, 0x6E, 0xA6, 0xFE, 0xB7, 0xFD, 0x3E, 0xA0, 0x74, - 0x08, 0x9C, 0xB9, 0x1C, 0x64, 0x89, 0x25, 0x28, 0x99, 0x98, 0x7F, 0xFF, 0x99, 0x14, 0xA2, 0x38, - 0x7B, 0xFF, 0x44, 0x7B, 0x38, 0xE1, 0x13, 0x92, 0x9B, 0x55, 0x08, 0x2C, 0x3A, 0x26, 0x3F, 0x44, - 0x1C, 0xB8, 0x4E, 0x60, 0x60, 0xE9, 0x80, 0x4C, 0xC7, 0x13, 0x68, 0x98, 0xAC, 0xD8, 0x4C, 0x5A, - 0x9C, 0x29, 0x9B, 0x04, 0x48, 0x19, 0x38, 0xF1, 0xF1, 0x20, 0x93, 0x47, 0x97, 0xFF, 0xFB, 0x92, - 0x64, 0x11, 0x87, 0x14, 0x99, 0x34, 0x4E, 0x0B, 0x9D, 0xD9, 0x84, 0x32, 0x06, 0x59, 0x51, 0x1D, - 0x85, 0xD0, 0x51, 0xA8, 0xD1, 0x3D, 0x0D, 0x77, 0x64, 0x40, 0xC5, 0x9A, 0x26, 0xE0, 0xC0, 0x1C, - 0x9A, 0xC0, 0xD9, 0x7C, 0x8F, 0x60, 0x09, 0xA6, 0x16, 0x13, 0xCC, 0x10, 0x19, 0xB1, 0x08, 0x86, - 0x00, 0x45, 0xAF, 0xCB, 0x08, 0x4D, 0x3A, 0x6A, 0x85, 0xB0, 0x93, 0xCD, 0x0D, 0x22, 0xA6, 0x7B, - 0xC0, 0x54, 0x1B, 0x77, 0xA6, 0xCC, 0x14, 0xA4, 0x0E, 0x3B, 0x75, 0x39, 0x83, 0x16, 0x5C, 0xC6, - 0x30, 0x0E, 0x01, 0x82, 0xE4, 0x45, 0xAA, 0x86, 0x20, 0x03, 0x2B, 0x48, 0x73, 0x6D, 0x01, 0x41, - 0xD5, 0xF4, 0xA5, 0x74, 0xA7, 0x16, 0x0D, 0x81, 0xEF, 0xCD, 0xEA, 0x1A, 0x00, 0xC2, 0xE3, 0x66, - 0xBD, 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x20, 0xBE, 0x3E, 0x21, 0xC1, 0xD0, - 0xA5, 0xF0, 0x30, 0x55, 0x12, 0xB1, 0x29, 0xDF, 0x28, 0x67, 0xA9, 0x9B, 0xB1, 0x10, 0x2B, 0x30, - 0x94, 0x20, 0x11, 0xF2, 0x63, 0x86, 0xBF, 0xFF, 0xCF, 0x52, 0x6D, 0x70, 0x22, 0xDD, 0x41, 0xFB, - 0x98, 0x63, 0x1E, 0xFE, 0x50, 0x24, 0x73, 0xE8, 0x43, 0x4B, 0x9F, 0x71, 0xD8, 0xA1, 0x67, 0x1B, - 0xC0, 0x2A, 0xCA, 0xDC, 0xC4, 0x76, 0xFF, 0xFF, 0x40, 0x10, 0xA1, 0xE8, 0x83, 0x71, 0x30, 0x3A, - 0xB8, 0xD2, 0xAA, 0xC0, 0x03, 0x02, 0x15, 0x02, 0x6B, 0x2A, 0x1B, 0xE5, 0xA0, 0x40, 0xC7, 0x40, - 0xC9, 0x90, 0xE4, 0x71, 0x83, 0xA0, 0x01, 0x94, 0x62, 0x79, 0xA1, 0x74, 0x28, 0x38, 0xB0, 0xC2, - 0x86, 0x0E, 0x17, 0x90, 0x0C, 0x58, 0x22, 0x23, 0x32, 0xDF, 0x53, 0x52, 0x0D, 0x5C, 0x62, 0x32, - 0xB4, 0x82, 0x69, 0x42, 0x84, 0x8D, 0xC6, 0x93, 0xA5, 0x01, 0x52, 0x78, 0x29, 0x3D, 0xE2, 0xD4, - 0x86, 0x16, 0x18, 0xF7, 0x3E, 0xC5, 0x61, 0x4D, 0x75, 0x43, 0x4C, 0x76, 0x1C, 0x59, 0xC5, 0xCB, - 0x43, 0x80, 0xF1, 0x04, 0xA5, 0xBB, 0x13, 0x07, 0xE3, 0x3E, 0xDE, 0x36, 0x2A, 0xE6, 0x1C, 0x5F, - 0x45, 0x98, 0x80, 0x2D, 0xD5, 0xAE, 0x81, 0x4D, 0xF7, 0xD3, 0xC1, 0xFB, 0x86, 0xDE, 0x48, 0x7A, - 0x62, 0x9F, 0x2F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0xD6, 0xAF, 0xC4, 0x4B, 0xB9, - 0x6B, 0x13, 0x07, 0x05, 0x96, 0xE0, 0xEF, 0x76, 0xE3, 0x89, 0x96, 0xDE, 0x25, 0x10, 0x78, 0x22, - 0xA8, 0x00, 0x60, 0x01, 0x0C, 0x13, 0xF8, 0x0D, 0x26, 0xCF, 0x63, 0x1F, 0x1C, 0xBF, 0x51, 0xE8, - 0xF9, 0xE0, 0xEC, 0x63, 0xCC, 0x80, 0xB1, 0xF2, 0xA5, 0xD0, 0x73, 0xA9, 0xE5, 0xD4, 0x38, 0xB1, - 0x51, 0x1C, 0x79, 0xD1, 0x31, 0xBB, 0xFF, 0xFF, 0xF3, 0xCB, 0xB1, 0x51, 0xBF, 0xA9, 0x99, 0x51, - 0x7C, 0x7D, 0x80, 0x00, 0x18, 0x00, 0xDB, 0xA4, 0x01, 0x86, 0x25, 0x71, 0x9B, 0xE0, 0x48, 0x14, - 0x24, 0x30, 0xF0, 0x5B, 0x16, 0xB8, 0x0C, 0x08, 0x06, 0xCC, 0x9A, 0x0C, 0x0C, 0x4E, 0xB1, 0xFF, - 0xFB, 0x92, 0x64, 0x0E, 0x8D, 0x94, 0x67, 0x34, 0xCE, 0xB3, 0xBB, 0x9B, 0x70, 0x30, 0xA5, 0xD9, - 0xF4, 0x28, 0x45, 0xA6, 0x51, 0x38, 0xD1, 0x3A, 0x0E, 0xE9, 0xEF, 0x48, 0xAA, 0x17, 0x66, 0xE0, - 0x64, 0x15, 0x58, 0x84, 0x83, 0xF6, 0xBA, 0x60, 0x7A, 0x9E, 0x9E, 0xE3, 0xA0, 0xC9, 0xCA, 0x6A, - 0x9A, 0x28, 0x2A, 0x91, 0x0A, 0x0C, 0x83, 0x93, 0xDF, 0x11, 0x08, 0xD2, 0x6B, 0xD3, 0x2B, 0x3B, - 0xA9, 0x5F, 0x12, 0xE5, 0x67, 0xD3, 0x10, 0x05, 0x7B, 0xAF, 0xA9, 0xB5, 0x44, 0xF7, 0x31, 0x48, - 0x71, 0x22, 0xF2, 0xCE, 0x24, 0xB1, 0x11, 0x4D, 0x58, 0xF8, 0xD0, 0xF5, 0x89, 0x63, 0x63, 0x7A, - 0xD5, 0x94, 0xCB, 0x46, 0x20, 0x67, 0xF0, 0x50, 0x42, 0x04, 0x8E, 0xB0, 0x6A, 0xBA, 0x6B, 0x10, - 0xAA, 0x49, 0x96, 0xA2, 0xFA, 0xD0, 0x33, 0x64, 0x13, 0xFF, 0xFF, 0xAC, 0x5E, 0x06, 0x25, 0x27, - 0x47, 0x40, 0x1F, 0x0C, 0x1B, 0x19, 0x0C, 0x16, 0x15, 0x44, 0x0E, 0xB5, 0x0C, 0xB8, 0x69, 0x22, - 0x28, 0x32, 0x0C, 0x00, 0x00, 0x0C, 0x67, 0x2A, 0xA4, 0x88, 0xFF, 0xFC, 0xCC, 0xF1, 0x51, 0xF1, - 0x70, 0x23, 0x0F, 0xD5, 0xE2, 0xF2, 0xC1, 0x90, 0xE7, 0xE1, 0x80, 0x18, 0x04, 0x75, 0x2B, 0x8A, - 0x6D, 0x5C, 0xD1, 0x2E, 0xCA, 0xD0, 0xC3, 0x66, 0x7F, 0xFF, 0xFE, 0x47, 0x60, 0xB0, 0x01, 0xBF, - 0xA6, 0xE8, 0xA0, 0xB8, 0x82, 0x04, 0x8C, 0x23, 0x1B, 0xC4, 0xA3, 0x30, 0x80, 0x3C, 0xC4, 0x92, - 0x10, 0xC3, 0x92, 0xE4, 0xC0, 0xC0, 0x90, 0xC3, 0x92, 0x4C, 0xD9, 0x4A, 0x3D, 0x15, 0x87, 0x81, - 0x33, 0x20, 0x10, 0x46, 0xA6, 0x42, 0x0B, 0x18, 0xC4, 0x74, 0x07, 0x0A, 0xCF, 0xE2, 0x34, 0x0F, - 0x2F, 0x6B, 0xA3, 0x87, 0x84, 0x8D, 0xD3, 0x2C, 0x95, 0x79, 0x76, 0x48, 0x3C, 0x82, 0x5B, 0x2B, - 0x08, 0x3C, 0xF3, 0x66, 0x14, 0x03, 0x1C, 0x66, 0x46, 0xA3, 0x50, 0x38, 0xF3, 0x39, 0x43, 0x62, - 0x25, 0x32, 0xE7, 0xAE, 0x29, 0x1D, 0xE5, 0xB7, 0xAD, 0x55, 0x48, 0xA4, 0x2D, 0x58, 0x90, 0x84, - 0x4D, 0x9D, 0x80, 0xAB, 0x66, 0xB1, 0xA1, 0x1D, 0x74, 0xDC, 0x81, 0x3F, 0x99, 0x95, 0x7A, 0xFF, - 0xFF, 0xE9, 0xAF, 0xFE, 0x29, 0xFF, 0xFF, 0x98, 0x03, 0xCD, 0x54, 0x0E, 0xE1, 0xBA, 0x19, 0x47, - 0x71, 0x5F, 0x65, 0x60, 0x64, 0x69, 0x70, 0x2B, 0xA8, 0x4A, 0x98, 0x24, 0x62, 0x0C, 0xC0, 0xB9, - 0xA1, 0x31, 0x1F, 0xDE, 0xE9, 0x05, 0x3F, 0xF3, 0xE4, 0x8A, 0xC4, 0xB9, 0xC0, 0x3B, 0xDB, 0xE6, - 0xE0, 0x28, 0xA9, 0x4E, 0x67, 0x21, 0xCA, 0xB4, 0x0B, 0x12, 0xB0, 0x90, 0xB0, 0xB7, 0xFB, 0xFF, - 0xFF, 0xF4, 0x34, 0xA3, 0x5B, 0x91, 0x3E, 0x6D, 0x6B, 0x82, 0xA0, 0x04, 0x04, 0x10, 0xF3, 0x11, - 0x30, 0x60, 0x21, 0x05, 0x30, 0x70, 0x65, 0x19, 0x36, 0x84, 0x01, 0x82, 0xF8, 0x2F, 0x98, 0x1A, - 0x02, 0xA9, 0xA4, 0x79, 0x18, 0x19, 0xAC, 0x0E, 0x62, 0x02, 0xA9, 0xE9, 0xEE, 0xE4, 0x21, 0xB0, - 0xA8, 0xFF, 0xFB, 0x92, 0x64, 0x14, 0x8F, 0x14, 0xEB, 0x34, 0xCD, 0x03, 0xDC, 0xD2, 0x20, 0x30, - 0xE3, 0x59, 0xEC, 0x09, 0x82, 0x32, 0x11, 0x2C, 0xD5, 0x3A, 0x0E, 0xE9, 0xEF, 0x80, 0xCC, 0x97, - 0xE8, 0x74, 0xC1, 0x89, 0x79, 0x90, 0xD8, 0xE5, 0xC0, 0xC2, 0xC2, 0x03, 0x88, 0x62, 0x01, 0x91, - 0x28, 0xD0, 0xCC, 0x25, 0x82, 0x95, 0x31, 0x92, 0x23, 0x12, 0x21, 0x41, 0x00, 0xA0, 0x35, 0xDC, - 0x31, 0x6B, 0xB1, 0x98, 0x00, 0x04, 0x5A, 0x85, 0xC8, 0x3E, 0x30, 0x87, 0x98, 0x36, 0xE2, 0x88, - 0xD1, 0xBE, 0x81, 0xA6, 0x0D, 0x0F, 0x8F, 0x36, 0x15, 0x5E, 0xE0, 0x0E, 0x0A, 0x33, 0xC4, 0xE1, - 0xA5, 0xB6, 0x62, 0x49, 0x40, 0x8C, 0x2C, 0x39, 0x55, 0xFA, 0x43, 0x00, 0x17, 0x91, 0xC5, 0xED, - 0x22, 0x98, 0x58, 0x06, 0xA5, 0xFF, 0xFF, 0xFF, 0xAA, 0x97, 0xBE, 0xA5, 0x8D, 0x6F, 0xFF, 0xFF, - 0xEE, 0x28, 0xD3, 0x85, 0x16, 0x25, 0x14, 0xC1, 0x9F, 0xA7, 0x0D, 0x51, 0x4A, 0xD9, 0x50, 0x90, - 0xB8, 0x62, 0x44, 0x4C, 0x2E, 0x06, 0x7F, 0x11, 0xD3, 0x84, 0x00, 0x00, 0xA0, 0x00, 0x0C, 0x00, - 0x94, 0x58, 0x70, 0xF8, 0x72, 0xC1, 0x7C, 0x5E, 0x57, 0x1F, 0x3A, 0x69, 0x41, 0x13, 0xD4, 0xA2, - 0xE0, 0x67, 0x3D, 0x09, 0xE1, 0x80, 0x40, 0x16, 0xCB, 0x42, 0x12, 0x0E, 0xC5, 0xBC, 0xF9, 0x47, - 0x75, 0x7E, 0x7C, 0x44, 0x11, 0x0C, 0x13, 0x68, 0x8D, 0x04, 0xE1, 0xD4, 0x18, 0x30, 0x38, 0xAD, - 0x31, 0xF8, 0x2A, 0x53, 0x53, 0x22, 0x0B, 0xD3, 0x1D, 0x87, 0x80, 0x20, 0x1E, 0x62, 0x59, 0x2C, - 0x75, 0x60, 0xC8, 0x61, 0xD0, 0x42, 0x21, 0x13, 0x8D, 0x8A, 0x2D, 0x07, 0x85, 0xA4, 0x17, 0x30, - 0xD0, 0x93, 0x7B, 0x1C, 0xE0, 0x49, 0x66, 0x08, 0xFF, 0x8E, 0xA0, 0x53, 0x6E, 0x34, 0x82, 0xB0, - 0x17, 0xDB, 0x3A, 0x17, 0x4C, 0xA6, 0x42, 0x9B, 0xC2, 0xE3, 0x41, 0xC4, 0x1C, 0xD6, 0xCA, 0x64, - 0x2F, 0xAE, 0xF7, 0x89, 0x47, 0xD6, 0x9D, 0x3A, 0x64, 0x4F, 0xE6, 0xDC, 0x60, 0xF8, 0xF0, 0xA8, - 0x64, 0xA2, 0x7B, 0xD9, 0x8A, 0x7C, 0xE6, 0xF6, 0x91, 0x04, 0xA5, 0xB4, 0xEB, 0x53, 0x4C, 0x52, - 0xC3, 0x76, 0x27, 0xA4, 0x5F, 0xFF, 0xEF, 0x95, 0x7E, 0xBD, 0xBE, 0x23, 0xFC, 0x53, 0xDF, 0x92, - 0x3C, 0xF4, 0x2C, 0xC6, 0x63, 0x36, 0x4F, 0xBE, 0x3E, 0x06, 0xB3, 0x40, 0xD1, 0x21, 0xCC, 0xE6, - 0x70, 0x99, 0xC5, 0xDE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x46, 0x4D, 0xC4, 0xB0, 0x4C, 0xEA, - 0x94, 0xA4, 0xEC, 0x3F, 0x08, 0x5B, 0xCA, 0x86, 0x82, 0xBC, 0x28, 0x83, 0x0A, 0x8D, 0x4D, 0x7F, - 0xE9, 0x2F, 0x1D, 0x38, 0xC3, 0x89, 0x87, 0xA3, 0x3E, 0xD3, 0x2D, 0x7F, 0xD5, 0xBA, 0x7F, 0x35, - 0x10, 0xC8, 0x29, 0xAA, 0x7C, 0xBC, 0x55, 0x6E, 0x20, 0xD0, 0x10, 0xC1, 0x41, 0xFC, 0xDC, 0x21, - 0x20, 0x28, 0x08, 0x18, 0xD8, 0x14, 0x1C, 0x60, 0x16, 0x18, 0x0C, 0x0E, 0x99, 0x62, 0x8F, 0x98, - 0x76, 0x9B, 0x98, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x0F, 0x94, 0x7B, 0x34, 0x4E, 0x03, 0xBA, 0x7B, - 0x60, 0x32, 0xC6, 0x59, 0xA2, 0x2C, 0xC2, 0x76, 0x50, 0xD4, 0xD1, 0x3C, 0x0E, 0xE1, 0xEE, 0xC0, - 0xB8, 0x19, 0x65, 0x18, 0x27, 0xA9, 0x9B, 0x4E, 0x03, 0x18, 0x60, 0x89, 0x19, 0x7E, 0x66, 0x95, - 0x01, 0xC5, 0xA4, 0x62, 0x2D, 0x0F, 0x1B, 0x4B, 0x83, 0x1A, 0x14, 0x58, 0x0C, 0x32, 0x82, 0x25, - 0x96, 0xCD, 0xC2, 0xE1, 0x47, 0x84, 0x64, 0xF6, 0xAF, 0x68, 0xF0, 0x00, 0x02, 0x11, 0xB9, 0x68, - 0x20, 0x59, 0x76, 0x59, 0x38, 0x25, 0x52, 0x23, 0xC4, 0x90, 0x8D, 0xAD, 0x43, 0x6A, 0x06, 0xA4, - 0x57, 0x21, 0x7E, 0x1C, 0x24, 0x87, 0x59, 0xF1, 0xD7, 0x51, 0x6D, 0xB1, 0x46, 0x98, 0x79, 0x04, - 0x4C, 0x4B, 0x97, 0x99, 0x1B, 0xA6, 0x42, 0x31, 0xE6, 0xDF, 0xFF, 0xBC, 0xCD, 0x22, 0x67, 0xCF, - 0x24, 0x6C, 0xB3, 0xE1, 0xF2, 0x10, 0x9F, 0x39, 0x32, 0xE9, 0x00, 0x28, 0x4D, 0x71, 0xC0, 0x96, - 0xE4, 0x18, 0xF0, 0x54, 0x92, 0x95, 0x88, 0x64, 0x09, 0x6D, 0x00, 0x18, 0x01, 0x48, 0x88, 0x14, - 0x4D, 0x6B, 0x44, 0xEE, 0x6A, 0xB7, 0xC0, 0x64, 0x59, 0x00, 0xD4, 0x0C, 0x2A, 0xFE, 0x77, 0x4D, - 0xC5, 0x07, 0x9E, 0x70, 0xBC, 0xFC, 0xB3, 0x23, 0x89, 0x0B, 0x45, 0x5F, 0x0C, 0x18, 0x93, 0x8C, - 0x6F, 0x2F, 0xF6, 0x5F, 0xFD, 0x56, 0x6B, 0x3C, 0xB6, 0x83, 0x0E, 0x56, 0x86, 0xE6, 0x92, 0xC6, - 0x0D, 0x18, 0xC6, 0xF3, 0x04, 0x08, 0xD2, 0x60, 0xE9, 0xE8, 0x66, 0x71, 0x0E, 0x60, 0x90, 0x52, - 0x61, 0xC0, 0x6C, 0x72, 0x18, 0x28, 0x60, 0xF8, 0x04, 0x61, 0x19, 0x44, 0x6E, 0x68, 0xDC, 0x8F, - 0xEC, 0x20, 0x02, 0x16, 0x21, 0x03, 0xBE, 0x56, 0x27, 0x37, 0x24, 0xC9, 0x45, 0x07, 0x58, 0x10, - 0x11, 0xA0, 0xD8, 0x50, 0xE9, 0x53, 0x33, 0x2E, 0x92, 0x39, 0xB9, 0x25, 0x9A, 0x06, 0x81, 0xC7, - 0x08, 0xA0, 0x38, 0xD8, 0x61, 0x9B, 0xE3, 0x0C, 0xDC, 0x3D, 0xCC, 0x20, 0x33, 0xB2, 0xB0, 0x9D, - 0x6C, 0xE6, 0x09, 0x09, 0x53, 0x2E, 0x4C, 0x22, 0x43, 0x00, 0xE4, 0x92, 0x12, 0xA4, 0xE0, 0x7E, - 0xA3, 0xDF, 0xFF, 0xFF, 0xDB, 0xD8, 0x2C, 0xE1, 0xE8, 0xE7, 0xBF, 0x2A, 0xAE, 0x3E, 0xD4, 0x6A, - 0x33, 0x51, 0x4C, 0xAF, 0x25, 0xE8, 0xC4, 0xC1, 0xBF, 0x12, 0xAB, 0xE8, 0x03, 0xA8, 0xA0, 0x6D, - 0x2F, 0x03, 0xD4, 0xFA, 0x00, 0x14, 0x2A, 0x7F, 0xF6, 0x26, 0x26, 0x2B, 0xE8, 0x3A, 0x61, 0x8B, - 0x5A, 0xCA, 0xA3, 0xAF, 0x5C, 0x3B, 0xAD, 0x48, 0x50, 0xDF, 0xE8, 0x3E, 0x5F, 0x56, 0xD5, 0x86, - 0x40, 0xD6, 0x7E, 0x67, 0xFF, 0xB2, 0x3F, 0xFD, 0x3C, 0xC0, 0x2E, 0x38, 0xE9, 0xCA, 0x3D, 0x26, - 0xC5, 0x95, 0x75, 0x44, 0x80, 0xE3, 0x0B, 0xA3, 0xC3, 0xD3, 0x01, 0x70, 0xE0, 0xA4, 0xCE, 0x78, - 0x98, 0x78, 0x9A, 0x31, 0x14, 0x5C, 0x31, 0x05, 0x80, 0x34, 0x2C, 0x26, 0x4F, 0x03, 0x26, 0xAD, - 0x33, 0x5C, 0x63, 0x48, 0x0F, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x8F, 0xD4, 0xBA, 0x34, 0xCD, 0x03, - 0xBB, 0xC2, 0x20, 0x2F, 0xA6, 0x38, 0xB0, 0x09, 0xAB, 0x8C, 0x50, 0xF4, 0xD3, 0x38, 0x0E, 0xE9, - 0xE8, 0x80, 0xC3, 0x18, 0xA3, 0xC4, 0xD1, 0xA9, 0x20, 0x1E, 0x43, 0x06, 0x83, 0x8D, 0x3C, 0x18, - 0x70, 0x21, 0x80, 0xAF, 0xB4, 0x9D, 0xAD, 0x13, 0x10, 0xB8, 0x00, 0xB7, 0x42, 0xF6, 0x59, 0x46, - 0x0A, 0x4A, 0xD0, 0xC8, 0x32, 0x82, 0xCC, 0xB4, 0x01, 0x0A, 0x14, 0xAD, 0x92, 0x82, 0x26, 0xA0, - 0x40, 0x24, 0x83, 0x00, 0xAE, 0x56, 0xFC, 0x3A, 0xAA, 0x4A, 0x61, 0x4F, 0x32, 0xAA, 0xAC, 0xDA, - 0x0C, 0x4F, 0xC8, 0xFB, 0x47, 0x5A, 0xEE, 0xD2, 0x9B, 0x2F, 0xB6, 0x71, 0x31, 0x32, 0xFE, 0x54, - 0x9A, 0xA3, 0xEF, 0xFD, 0xDD, 0xFC, 0xB2, 0x24, 0xCB, 0x70, 0x9D, 0xF9, 0x24, 0xF4, 0xC4, 0xCB, - 0xFB, 0x0D, 0xC3, 0xF0, 0xDC, 0x1E, 0xEF, 0x3B, 0x0B, 0x59, 0x51, 0x34, 0xB4, 0x55, 0x7D, 0xE7, - 0xDE, 0xDE, 0x33, 0x96, 0xD2, 0x05, 0x5C, 0xCA, 0xE9, 0x63, 0x36, 0x78, 0xAF, 0x43, 0x4A, 0xDF, - 0xF6, 0x0C, 0x0C, 0x05, 0x0A, 0x8E, 0x5C, 0x18, 0x44, 0x21, 0xBA, 0x60, 0x9D, 0x12, 0x9E, 0x8A, - 0xBF, 0xBA, 0xFF, 0xD4, 0x81, 0xA3, 0x85, 0xB8, 0x86, 0xC2, 0x5C, 0x32, 0x5E, 0xA6, 0xFF, 0xFD, - 0x4F, 0x41, 0x8C, 0x38, 0xCA, 0xFB, 0x0C, 0x81, 0x54, 0x7C, 0x90, 0x59, 0xCC, 0x9E, 0xC3, 0x20, - 0x89, 0x84, 0x54, 0x01, 0xBC, 0x45, 0x19, 0x82, 0x40, 0x79, 0x8A, 0xA8, 0xB1, 0xA9, 0x61, 0xB9, - 0x85, 0xC0, 0x89, 0x84, 0xA8, 0xB1, 0xAA, 0x25, 0x91, 0x8B, 0x26, 0x5B, 0xA3, 0xE1, 0x54, 0x0D, - 0x31, 0x0C, 0x40, 0x05, 0x09, 0xA8, 0x2B, 0x68, 0x63, 0x27, 0x9C, 0x09, 0x19, 0x2A, 0x36, 0x02, - 0x9A, 0x1A, 0x2C, 0x1F, 0x27, 0x68, 0xDF, 0x0A, 0x50, 0xA7, 0x12, 0xA1, 0x01, 0x0E, 0x50, 0xA5, - 0x32, 0x86, 0xF8, 0xE2, 0x08, 0x70, 0x63, 0x82, 0xBA, 0x56, 0x52, 0x31, 0x06, 0x3C, 0x66, 0x31, - 0xE2, 0x9E, 0x8C, 0xF8, 0xF5, 0x45, 0x21, 0x03, 0x78, 0xE9, 0x2F, 0xD0, 0x23, 0x2B, 0xED, 0x1A, - 0xDF, 0x38, 0x82, 0xC1, 0x10, 0xF3, 0xB3, 0x9A, 0x71, 0xD7, 0x5E, 0xF2, 0x32, 0x23, 0xE2, 0xB3, - 0xBF, 0x3B, 0x55, 0x4E, 0xD5, 0x4B, 0x48, 0x62, 0x61, 0x39, 0x16, 0xB2, 0x38, 0xBC, 0x3F, 0x36, - 0xF9, 0x0F, 0x6C, 0x8F, 0x80, 0x9B, 0x06, 0xF9, 0xB3, 0x7F, 0xD1, 0x7F, 0xC4, 0x89, 0xC4, 0x70, - 0x63, 0x33, 0x0B, 0x24, 0xBB, 0xCF, 0x71, 0xFB, 0xCC, 0x24, 0x6D, 0xFF, 0x3F, 0x02, 0xC2, 0x53, - 0x4C, 0x3A, 0x0E, 0x8D, 0x3F, 0xFF, 0xAF, 0x17, 0x85, 0xD1, 0xA0, 0x6C, 0x2F, 0xC8, 0xFA, 0x98, - 0x25, 0xBC, 0x60, 0x14, 0x65, 0x95, 0x02, 0x82, 0x80, 0x01, 0x24, 0xC7, 0xBC, 0xE0, 0xD8, 0xF5, - 0x04, 0xC2, 0xB1, 0x28, 0xC7, 0xE0, 0xEC, 0xE6, 0xF0, 0xF8, 0xC7, 0x30, 0xA0, 0xC3, 0x93, 0x48, - 0xE6, 0xC0, 0x54, 0xCD, 0x81, 0x8B, 0xE8, 0xFF, 0xFB, 0x92, 0x64, 0x10, 0x8F, 0x24, 0xA5, 0x34, - 0xCD, 0x03, 0xBB, 0x7A, 0x70, 0x2F, 0x65, 0xE9, 0x81, 0x1D, 0x05, 0x6A, 0x91, 0xD0, 0xD1, 0x38, - 0x0F, 0x73, 0x42, 0x80, 0xCB, 0x97, 0xE6, 0xA0, 0x56, 0x0A, 0x18, 0x6E, 0x32, 0xA4, 0x4D, 0x68, - 0x1C, 0x6D, 0x45, 0xA4, 0xC8, 0xA9, 0x80, 0x5B, 0x96, 0xBD, 0x59, 0xD5, 0x55, 0x44, 0xCD, 0x7C, - 0x27, 0x9B, 0x89, 0x50, 0x05, 0xD7, 0x08, 0x1D, 0x2E, 0xCB, 0xD0, 0x5F, 0x15, 0xCE, 0x18, 0x82, - 0x92, 0xA9, 0x20, 0x4A, 0x14, 0x34, 0x5C, 0xAC, 0xC8, 0x3C, 0x80, 0xBB, 0x7A, 0x43, 0x99, 0xBE, - 0x71, 0x2C, 0x0F, 0xB1, 0xD8, 0x06, 0x73, 0x8C, 0xAD, 0x30, 0x54, 0xA3, 0x78, 0xBD, 0x12, 0x83, - 0xFD, 0xC1, 0xC9, 0x52, 0xAD, 0xCE, 0xBB, 0x6A, 0xD2, 0x1C, 0xA9, 0xD2, 0x7D, 0x70, 0xB9, 0x38, - 0xEB, 0x89, 0x66, 0xB2, 0x40, 0xBB, 0xC7, 0x1F, 0x62, 0x42, 0x78, 0x43, 0x34, 0x54, 0x4E, 0x95, - 0x65, 0xE1, 0xAD, 0x3F, 0xB5, 0xC2, 0xCA, 0xA1, 0x42, 0xB9, 0x54, 0xA2, 0xEA, 0xA0, 0xC8, 0x10, - 0x04, 0xC0, 0x2C, 0x37, 0xFE, 0x2B, 0x25, 0xF9, 0x64, 0x25, 0x61, 0xDB, 0xC2, 0x20, 0xB8, 0xB8, - 0xBB, 0x2D, 0xD6, 0x0E, 0x06, 0xC6, 0x87, 0xEE, 0x0A, 0xCF, 0xD1, 0x1B, 0x57, 0x91, 0x22, 0x4E, - 0xF3, 0xD6, 0xDD, 0x1B, 0xFE, 0x77, 0xF5, 0x08, 0x07, 0xDF, 0xE1, 0xE0, 0xE7, 0x90, 0x4B, 0xA0, - 0x80, 0x45, 0x30, 0x4F, 0x09, 0x63, 0x44, 0xD0, 0x89, 0x33, 0x48, 0xE8, 0x60, 0x6E, 0x7F, 0xC4, - 0x30, 0x88, 0x7A, 0x38, 0x15, 0x37, 0x2B, 0x18, 0xDB, 0x05, 0x31, 0x24, 0x4C, 0xA6, 0x70, 0xCC, - 0xE2, 0x85, 0x0D, 0x41, 0xB0, 0x08, 0x55, 0x03, 0x6B, 0xEE, 0x7D, 0x1C, 0x1E, 0xDD, 0x9F, 0xE5, - 0xEB, 0x3B, 0x00, 0xAE, 0x59, 0x10, 0xB0, 0x34, 0x1F, 0x58, 0x83, 0x40, 0x91, 0xF0, 0x78, 0x81, - 0x7F, 0x40, 0xC7, 0x02, 0x83, 0x04, 0x21, 0x04, 0x22, 0x40, 0xA0, 0xD9, 0x95, 0xA9, 0x43, 0x0C, - 0x6E, 0xCE, 0x82, 0xEC, 0x7C, 0x9C, 0x56, 0x64, 0xFA, 0x3F, 0x91, 0x4B, 0xF0, 0xEC, 0x47, 0x73, - 0xBD, 0xA0, 0x93, 0x53, 0x7F, 0xFE, 0xDC, 0x19, 0x74, 0x7A, 0xD4, 0x62, 0x4B, 0x1F, 0x97, 0x77, - 0x7B, 0xF8, 0xED, 0x78, 0x1E, 0x72, 0x7F, 0x06, 0x0E, 0xE4, 0xB7, 0x18, 0x7A, 0x00, 0x7D, 0xA4, - 0x50, 0x25, 0x37, 0x68, 0x27, 0x5E, 0xBB, 0x34, 0xB0, 0xEC, 0x7B, 0x52, 0xD4, 0x00, 0x03, 0x00, - 0x1D, 0x12, 0x4F, 0xF0, 0xB1, 0x4F, 0x12, 0x41, 0x5A, 0x87, 0x22, 0x42, 0xD8, 0x50, 0xD2, 0xAC, - 0x5D, 0x24, 0x88, 0x66, 0x5E, 0x7A, 0x1A, 0x41, 0x1B, 0x0F, 0x3C, 0xC7, 0xBC, 0xC0, 0x9E, 0xC6, - 0x10, 0x8E, 0x86, 0x5F, 0x62, 0x12, 0x8F, 0x39, 0xEC, 0xFF, 0x87, 0x11, 0xF0, 0x41, 0x7D, 0x6A, - 0x48, 0xD0, 0x68, 0x34, 0x08, 0x43, 0xCC, 0x40, 0x76, 0x8C, 0x1E, 0x02, 0xCC, 0x0F, 0x17, 0x8D, - 0x1F, 0x8E, 0x0D, 0x40, 0x2B, 0x0C, 0x94, 0x80, 0xE8, 0xFF, 0xFB, 0x92, 0x64, 0x0C, 0x8F, 0x94, - 0x44, 0x33, 0xCE, 0x83, 0xBB, 0xC1, 0xA0, 0x30, 0x05, 0xB9, 0x75, 0x15, 0x02, 0x8C, 0xD1, 0xD0, - 0xCF, 0x34, 0x0E, 0xE9, 0xEB, 0xC0, 0xB4, 0x99, 0x64, 0xD8, 0x06, 0xAE, 0x1B, 0x91, 0xCF, 0x58, - 0x38, 0x04, 0x0C, 0x60, 0x83, 0x67, 0x04, 0x60, 0x9D, 0x0B, 0xCD, 0x29, 0x01, 0x43, 0x79, 0xE0, - 0x74, 0xC4, 0xAB, 0x42, 0x0D, 0x81, 0x12, 0x20, 0xBB, 0x85, 0xAF, 0x6B, 0xEA, 0xC0, 0x22, 0x28, - 0x38, 0x68, 0x12, 0x15, 0xF0, 0xB6, 0x13, 0x05, 0x3F, 0x01, 0x27, 0x72, 0xA4, 0x64, 0x00, 0x60, - 0xBF, 0x92, 0x99, 0xD0, 0xB7, 0x8A, 0xAE, 0xE6, 0x47, 0xD4, 0x4D, 0xEB, 0x6B, 0xF3, 0x4A, 0x51, - 0x18, 0x94, 0x42, 0xE8, 0x39, 0x5B, 0xBF, 0xFF, 0xFA, 0xCE, 0x1F, 0x61, 0xDC, 0xA0, 0x94, 0x63, - 0x6A, 0xF5, 0x4E, 0xFD, 0xD7, 0x6A, 0x82, 0x39, 0x2E, 0xAC, 0xFA, 0x3A, 0x2A, 0xF3, 0xAE, 0xF6, - 0x0D, 0xD9, 0xCD, 0x84, 0x6E, 0xB5, 0xE9, 0xCD, 0x38, 0xEF, 0xBB, 0xFD, 0xD0, 0x10, 0x00, 0x65, - 0xFF, 0x08, 0x81, 0x7A, 0xE6, 0xE5, 0x1A, 0xD6, 0x54, 0x60, 0x3E, 0xC2, 0x41, 0xF2, 0xBA, 0xAA, - 0xFE, 0xA9, 0xFB, 0x5F, 0xF1, 0x0E, 0x50, 0xCA, 0xF5, 0xFF, 0x36, 0x03, 0xA0, 0xF4, 0x5F, 0x28, - 0xFB, 0x89, 0x8E, 0x63, 0xC2, 0xB4, 0x20, 0x91, 0xB8, 0x77, 0xD8, 0x48, 0x86, 0x92, 0x0D, 0x00, - 0x41, 0xC5, 0xB9, 0xB3, 0x16, 0x28, 0x20, 0x09, 0x30, 0x0C, 0x2D, 0x32, 0xE6, 0x0D, 0x0D, 0xA8, - 0x0C, 0x12, 0x03, 0x4C, 0x71, 0x19, 0x4C, 0x65, 0x17, 0x92, 0x68, 0xCF, 0xEA, 0x3D, 0x69, 0x85, - 0x0A, 0x0E, 0xA4, 0x01, 0x1E, 0x3E, 0x29, 0x55, 0xEC, 0x90, 0x1C, 0x3D, 0x82, 0x3C, 0x65, 0xA9, - 0x26, 0xE9, 0xEF, 0x80, 0x11, 0x94, 0x8A, 0x88, 0x2A, 0x3C, 0x6D, 0xB3, 0x4F, 0x21, 0x08, 0x78, - 0x5A, 0x19, 0x80, 0xE5, 0xDC, 0x30, 0x33, 0x44, 0xF3, 0x33, 0x95, 0x9B, 0x41, 0xF7, 0xC1, 0x81, - 0xD8, 0x2E, 0x2E, 0x68, 0x38, 0xCB, 0xA7, 0x3C, 0xBE, 0x58, 0x7A, 0xC1, 0x59, 0x3A, 0x0B, 0x6B, - 0x19, 0x47, 0x36, 0xFD, 0xFF, 0xFE, 0x18, 0x54, 0x94, 0x48, 0x79, 0x8E, 0x35, 0x11, 0xAC, 0xAC, - 0x8F, 0x7F, 0x4C, 0xC1, 0x4E, 0xC9, 0x0D, 0x74, 0x10, 0x91, 0xDA, 0x41, 0x5E, 0x8B, 0x29, 0xAE, - 0x64, 0xCA, 0x8B, 0xA4, 0x93, 0xE9, 0xBD, 0x16, 0x4A, 0xD3, 0xFA, 0x11, 0x01, 0xBF, 0x95, 0x08, - 0xD0, 0x38, 0xC6, 0xCF, 0xA3, 0xDD, 0x7F, 0xE3, 0xE4, 0xDE, 0xD3, 0x10, 0x34, 0xDB, 0xE1, 0xD1, - 0xF0, 0xE7, 0x38, 0xA8, 0xB9, 0xDD, 0x35, 0xBB, 0xF6, 0x9A, 0xF3, 0xFD, 0x69, 0x03, 0x6D, 0xC7, - 0xB0, 0xF7, 0x7E, 0x90, 0xFA, 0x40, 0x0D, 0x4A, 0x55, 0x97, 0x08, 0x00, 0xF3, 0x09, 0x0D, 0x53, - 0x6F, 0xEA, 0x83, 0x14, 0x82, 0x13, 0x14, 0x00, 0x93, 0x09, 0x7A, 0x93, 0xC2, 0x06, 0xB1, 0xE2, - 0x24, 0xC2, 0x31, 0xDC, 0xD1, 0x02, 0x20, 0xC1, 0x40, 0x0C, 0xC5, 0xFF, 0xFB, 0x92, 0x64, 0x11, - 0x07, 0xA4, 0x9D, 0x33, 0x4D, 0x03, 0xBA, 0xC2, 0xE0, 0x30, 0x46, 0x69, 0x58, 0x08, 0xC7, 0xC0, - 0x11, 0x5C, 0xCF, 0x36, 0xAE, 0xE5, 0xEB, 0x90, 0xBF, 0x99, 0xA6, 0xC8, 0x13, 0x0D, 0x78, 0xB5, - 0x34, 0x53, 0x42, 0x12, 0x1A, 0x00, 0x40, 0x82, 0x26, 0x9A, 0xD3, 0x28, 0x7F, 0x47, 0x19, 0xBA, - 0x77, 0xE0, 0x50, 0x28, 0x97, 0xA9, 0x9E, 0x19, 0x90, 0x83, 0x41, 0x1D, 0x60, 0xB1, 0x93, 0x20, - 0xD9, 0x56, 0x30, 0xB3, 0x28, 0x85, 0x1E, 0x99, 0x60, 0xC5, 0x73, 0x22, 0x21, 0x58, 0x69, 0x28, - 0x67, 0xF6, 0xAA, 0xD2, 0xCB, 0x44, 0x26, 0x31, 0x81, 0x68, 0x2B, 0x4B, 0xFA, 0x5F, 0x2A, 0x67, - 0x29, 0x9E, 0xDB, 0x67, 0x14, 0xEE, 0x9D, 0xFD, 0xC1, 0x78, 0x73, 0xF7, 0xCA, 0xC1, 0xDB, 0x6A, - 0x70, 0x73, 0xC4, 0xE2, 0x49, 0x6C, 0x37, 0x9A, 0xE6, 0x31, 0xE8, 0x72, 0xDB, 0x11, 0x9A, 0x75, - 0xA0, 0xAD, 0x5A, 0x95, 0xB1, 0xDA, 0x39, 0x53, 0x85, 0xCD, 0x61, 0x8C, 0x13, 0x36, 0xAD, 0x90, - 0x30, 0x00, 0x01, 0x00, 0x40, 0x71, 0xFF, 0xF9, 0x0A, 0x06, 0x2F, 0xCE, 0xFE, 0x42, 0x5C, 0x28, - 0x92, 0x81, 0xB9, 0xD1, 0xA8, 0xDF, 0xB4, 0x40, 0x40, 0x38, 0xF4, 0x8C, 0xB9, 0x36, 0xAE, 0xDF, - 0xA2, 0x6F, 0xA9, 0xF4, 0xA0, 0xD1, 0x9C, 0x71, 0x8C, 0x9A, 0x86, 0x0A, 0x42, 0xDE, 0x2E, 0x23, - 0x2D, 0x03, 0xDA, 0x90, 0x46, 0x1F, 0x04, 0x07, 0x0E, 0x40, 0x26, 0x1C, 0x03, 0x86, 0x28, 0x09, - 0x66, 0x14, 0x77, 0xA7, 0x44, 0x02, 0x46, 0x2B, 0x02, 0xC1, 0x80, 0x19, 0xAC, 0x23, 0x88, 0x08, - 0x0F, 0x38, 0xA1, 0x35, 0x40, 0x0B, 0x18, 0x15, 0x26, 0x24, 0x64, 0x7A, 0xFC, 0x41, 0x42, 0x8D, - 0x91, 0x37, 0x5E, 0x34, 0x6A, 0x0D, 0x34, 0xED, 0x02, 0x01, 0x22, 0x26, 0xDA, 0x98, 0x1B, 0x5C, - 0xC6, 0x2B, 0x85, 0x8B, 0x54, 0x52, 0x50, 0xA0, 0xA6, 0x90, 0x31, 0x98, 0xD0, 0xB0, 0x8E, 0x74, - 0x55, 0xBF, 0xBD, 0x0F, 0x44, 0xA8, 0x2D, 0x42, 0x14, 0x1C, 0x82, 0xD0, 0x59, 0xA6, 0xC9, 0xEA, - 0x81, 0x13, 0x0C, 0xDC, 0xB5, 0xCF, 0x55, 0x9D, 0x7F, 0x75, 0xC8, 0x47, 0x4B, 0xD3, 0x0A, 0xF2, - 0x6E, 0x34, 0x04, 0x43, 0x86, 0x58, 0xDF, 0x30, 0xB1, 0x29, 0xA3, 0x1D, 0x09, 0xB2, 0xBF, 0x78, - 0x34, 0x9F, 0x3F, 0x50, 0xD7, 0x29, 0xF7, 0x24, 0xED, 0x1B, 0x22, 0x6C, 0xC0, 0x28, 0xFF, 0xFE, - 0x86, 0x1A, 0x3F, 0x7B, 0x29, 0xF7, 0xDE, 0x96, 0x08, 0x8F, 0xFF, 0xB8, 0x21, 0x03, 0x0F, 0x27, - 0xD3, 0xD8, 0xF7, 0xF9, 0x41, 0x17, 0x5D, 0xEC, 0xF7, 0x84, 0xEE, 0x7B, 0x17, 0xFD, 0x77, 0x99, - 0x7D, 0x3F, 0xC9, 0x67, 0x0C, 0xB3, 0x9D, 0x07, 0xF6, 0x2E, 0x20, 0x42, 0x2E, 0xD1, 0x80, 0x80, - 0x88, 0xF1, 0xDC, 0x6F, 0x9B, 0x34, 0x60, 0x88, 0xC0, 0x62, 0x28, 0x06, 0x63, 0x47, 0x5A, 0x70, - 0xC0, 0xA6, 0x61, 0x80, 0x7C, 0x61, 0x19, 0x18, 0x6A, 0x21, 0xB4, 0x50, 0x03, 0xFF, 0xFB, 0x92, - 0x64, 0x10, 0x8F, 0x64, 0x68, 0x33, 0x4D, 0x83, 0xB9, 0x7A, 0xF0, 0x2E, 0xE6, 0x69, 0xD1, 0x09, - 0x22, 0x5E, 0x92, 0x94, 0xCF, 0x36, 0x0F, 0x73, 0x46, 0x40, 0xA7, 0x16, 0xA7, 0x20, 0x53, 0x0A, - 0xCA, 0x1D, 0x6D, 0x9F, 0xE3, 0x82, 0x02, 0x37, 0xF7, 0x16, 0x5C, 0xFB, 0x80, 0xBE, 0x12, 0xD0, - 0x69, 0x63, 0xCB, 0x41, 0xAA, 0xC4, 0x62, 0x83, 0x72, 0xE0, 0xEA, 0x2F, 0x2C, 0xDA, 0x93, 0x3F, - 0xC6, 0x6A, 0x50, 0x00, 0x91, 0x0C, 0x7A, 0x65, 0x9D, 0x84, 0xBD, 0x1C, 0x61, 0x89, 0xDC, 0xEF, - 0x2D, 0xA5, 0x60, 0x90, 0x74, 0x2A, 0x08, 0x14, 0xF5, 0xC9, 0x21, 0x76, 0x94, 0xDE, 0x1D, 0x6B, - 0xA4, 0x1E, 0x93, 0x9C, 0x8D, 0x51, 0x72, 0x9C, 0x59, 0x8F, 0xF1, 0x11, 0x58, 0x87, 0x13, 0x67, - 0xD1, 0x2F, 0x59, 0x0B, 0x1A, 0xCF, 0x82, 0xA7, 0x59, 0xAD, 0x64, 0x55, 0x05, 0xF8, 0xFC, 0x4B, - 0xA5, 0xCF, 0xC6, 0xE7, 0x68, 0x4E, 0xF9, 0xFA, 0x73, 0x2A, 0x2C, 0x78, 0xBA, 0x02, 0x07, 0x01, - 0x15, 0xFF, 0xE5, 0xCF, 0x1C, 0x0D, 0x4F, 0x3B, 0x77, 0xE8, 0xC1, 0xAA, 0x56, 0xB7, 0xFF, 0x48, - 0x72, 0xE0, 0x95, 0xA2, 0x4E, 0x95, 0xFF, 0x99, 0x54, 0xC2, 0x3C, 0xF2, 0xA0, 0x43, 0xB1, 0x8A, - 0xFF, 0xEC, 0xE6, 0xF6, 0xF7, 0xF2, 0xD6, 0xC7, 0x6D, 0x65, 0x48, 0xCA, 0xF1, 0x21, 0x99, 0x83, - 0xD0, 0x1F, 0x99, 0x3F, 0x07, 0x39, 0x81, 0xD0, 0x06, 0x16, 0x00, 0x34, 0xC1, 0x8D, 0x1E, 0xCC, - 0x02, 0x42, 0x6C, 0xC3, 0xA4, 0x83, 0x5B, 0x0F, 0x4E, 0x4E, 0x99, 0x12, 0x19, 0x83, 0x94, 0x1A, - 0xDC, 0xA6, 0x2C, 0x18, 0xF0, 0x23, 0x3E, 0x04, 0x24, 0xEB, 0xDC, 0xA0, 0x26, 0x10, 0x13, 0xAD, - 0x36, 0x96, 0x80, 0xE0, 0x51, 0xD8, 0x04, 0xA0, 0xA3, 0x7F, 0x2A, 0x00, 0x11, 0x2B, 0x33, 0x02, - 0xBF, 0xE0, 0x60, 0x52, 0x87, 0xA0, 0x30, 0xC1, 0x40, 0x29, 0x6A, 0x3D, 0x30, 0x89, 0x03, 0x65, - 0x11, 0x00, 0xA0, 0x15, 0x06, 0x61, 0x51, 0xAB, 0x13, 0x8C, 0x5E, 0x50, 0x32, 0x27, 0x61, 0x91, - 0xAB, 0x4A, 0x97, 0x50, 0xB1, 0x74, 0xBB, 0x84, 0xD1, 0x6E, 0x7A, 0x53, 0x6B, 0xE6, 0x1E, 0x09, - 0x0B, 0xB5, 0x12, 0x76, 0x37, 0xDB, 0x18, 0xBC, 0xFD, 0xEE, 0xA6, 0x2D, 0xFF, 0xE9, 0xAA, 0xB8, - 0xAB, 0x90, 0x88, 0x23, 0xDD, 0x04, 0xB9, 0x79, 0x53, 0x73, 0x59, 0x41, 0x57, 0x6B, 0xFB, 0xF1, - 0xC6, 0x00, 0x00, 0x88, 0x18, 0xED, 0xFF, 0x11, 0x15, 0xA8, 0x23, 0x56, 0x54, 0x8B, 0x29, 0x3C, - 0x2F, 0xF2, 0x4D, 0x07, 0x4E, 0x8A, 0x5B, 0xD9, 0x43, 0x0D, 0x3F, 0x71, 0x93, 0x91, 0xA6, 0xFD, - 0x4F, 0x23, 0x29, 0x2F, 0xF5, 0xFD, 0x45, 0xC9, 0xEB, 0x7A, 0x6A, 0x7C, 0x13, 0x78, 0xC5, 0x12, - 0xC8, 0xEE, 0x12, 0xC4, 0xC4, 0x50, 0x18, 0xC6, 0xB0, 0x54, 0xDC, 0x6A, 0x34, 0xDB, 0x91, 0x04, - 0xC3, 0xA0, 0xE8, 0xCB, 0x94, 0x98, 0xDF, 0x70, 0x00, 0xC1, 0x90, 0x6C, 0xC5, 0x81, 0xD0, 0xFF, - 0xFB, 0x92, 0x64, 0x12, 0x07, 0xB4, 0xAA, 0x33, 0xCD, 0x03, 0xBA, 0x7B, 0x60, 0x2C, 0xE6, 0x39, - 0xE4, 0x04, 0x02, 0x08, 0xD1, 0x8C, 0xD1, 0x38, 0xAE, 0xE9, 0xED, 0x80, 0xBF, 0x97, 0x26, 0x40, - 0x24, 0x8A, 0x58, 0xC8, 0x24, 0x98, 0x1A, 0x0D, 0x83, 0x1E, 0x19, 0x19, 0x66, 0x98, 0x59, 0x6D, - 0x8B, 0x90, 0x11, 0x06, 0xA4, 0x32, 0x17, 0x69, 0x4F, 0x19, 0x67, 0xA8, 0x6A, 0xDB, 0x37, 0x33, - 0x46, 0x30, 0x68, 0x73, 0xE8, 0x1C, 0x91, 0xD7, 0x7E, 0x50, 0xEC, 0x59, 0xC8, 0x39, 0xB1, 0xA1, - 0x99, 0x7F, 0x15, 0xA5, 0x3B, 0xDB, 0x83, 0xF4, 0x28, 0x6C, 0x10, 0x79, 0x35, 0xD3, 0xD8, 0x05, - 0x31, 0x12, 0xDA, 0x18, 0xE8, 0xF7, 0x15, 0x3A, 0xF4, 0x3B, 0x1B, 0x73, 0x12, 0x0B, 0xC6, 0xCB, - 0x6A, 0x11, 0xCE, 0x95, 0x82, 0x40, 0x1C, 0xA0, 0x35, 0x38, 0xE6, 0x19, 0x69, 0xBC, 0x19, 0x88, - 0x0F, 0x87, 0xC7, 0xE9, 0x31, 0x0A, 0xA1, 0xCE, 0xE4, 0xB4, 0x1D, 0x2E, 0xAB, 0xAF, 0xCD, 0x85, - 0xA8, 0x2A, 0xC9, 0x5A, 0x00, 0x00, 0x08, 0x00, 0x07, 0x45, 0xE0, 0x4E, 0x45, 0xE8, 0xF1, 0xB4, - 0x21, 0x03, 0xE8, 0x57, 0x84, 0x06, 0x72, 0x02, 0x31, 0x06, 0x18, 0xA0, 0x85, 0x05, 0x0C, 0x11, - 0x0D, 0x50, 0x4D, 0xDA, 0xAC, 0xE6, 0xE8, 0xEA, 0x8D, 0xAB, 0xE6, 0xA1, 0x5D, 0xD5, 0x3E, 0x09, - 0xD2, 0xC0, 0xB5, 0x4B, 0xBC, 0x60, 0x29, 0x4E, 0x6C, 0x82, 0xBC, 0x60, 0x60, 0x72, 0x62, 0x09, - 0x04, 0x66, 0x86, 0xC4, 0x67, 0x18, 0x58, 0x60, 0x10, 0x0C, 0x62, 0x42, 0x2A, 0x67, 0x68, 0x1A, - 0x8F, 0x88, 0x46, 0x63, 0x3A, 0xCE, 0x61, 0x48, 0x0A, 0x24, 0x40, 0xC2, 0xD7, 0x30, 0xA4, 0xD9, - 0xC2, 0x1E, 0x02, 0x8F, 0xC5, 0xB6, 0x22, 0x4B, 0x6F, 0xAE, 0xE3, 0x24, 0x91, 0xB3, 0x10, 0x30, - 0xC9, 0x1B, 0xE0, 0x17, 0x30, 0xD6, 0x28, 0xD8, 0x52, 0x52, 0x4E, 0xB8, 0x6D, 0x11, 0x0C, 0xDE, - 0x55, 0xA3, 0x21, 0x8D, 0x37, 0xA4, 0xD1, 0x52, 0xE2, 0x2E, 0x66, 0xC2, 0xB6, 0x09, 0x94, 0x19, - 0x6A, 0xCC, 0xC7, 0xA1, 0x61, 0x54, 0x31, 0x9F, 0xF1, 0xE2, 0xA4, 0x1F, 0xEB, 0xC2, 0x9A, 0xB0, - 0xE4, 0xD3, 0x75, 0xF6, 0xD4, 0x93, 0x77, 0xD4, 0xCF, 0xFF, 0x48, 0xCE, 0x93, 0x0B, 0xD5, 0x43, - 0x00, 0x82, 0x92, 0xD5, 0x7F, 0xCE, 0xE8, 0xC5, 0x34, 0x06, 0xE2, 0xF6, 0xCF, 0x41, 0xBF, 0xF2, - 0x13, 0xA8, 0x20, 0x40, 0x3E, 0x83, 0xA5, 0x1D, 0x51, 0x1A, 0x12, 0x61, 0x36, 0xF5, 0xD5, 0x87, - 0x91, 0x68, 0xDE, 0x44, 0xA8, 0xDE, 0x7F, 0x99, 0xD5, 0x1A, 0x14, 0xE5, 0x6B, 0x8A, 0x2B, 0xAB, - 0x36, 0x26, 0x9A, 0x5F, 0xEC, 0x55, 0x76, 0x14, 0x38, 0x06, 0x59, 0x81, 0x62, 0x55, 0x7A, 0x10, - 0x6C, 0xC3, 0x82, 0xC0, 0xC1, 0x85, 0xAC, 0x50, 0x05, 0x30, 0xF8, 0x56, 0x34, 0x8E, 0x18, 0x35, - 0x28, 0x88, 0x30, 0x70, 0x19, 0x92, 0x98, 0xA2, 0x3E, 0x15, 0x00, 0x90, 0x82, 0x9C, 0xD2, 0x49, - 0x90, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x87, 0x34, 0x5B, 0x34, 0x4E, 0x03, 0xB9, 0x7B, 0x60, 0x2F, - 0xA5, 0xD9, 0x98, 0x1C, 0xC2, 0x96, 0x92, 0x00, 0xD3, 0x38, 0xAE, 0x69, 0xED, 0x90, 0xC3, 0x1A, - 0x26, 0xD0, 0x73, 0x16, 0x50, 0xC6, 0xC0, 0x58, 0x24, 0xF3, 0x60, 0xB3, 0xC4, 0x55, 0x35, 0x99, - 0x01, 0x2D, 0x2A, 0x78, 0x8C, 0x26, 0xA0, 0x09, 0xC7, 0xD9, 0x11, 0x65, 0x8F, 0xA0, 0x58, 0xF7, - 0xBA, 0x18, 0x10, 0x92, 0x3C, 0x66, 0xF0, 0x2C, 0xDA, 0xFC, 0x80, 0xCB, 0x00, 0x05, 0x01, 0x6A, - 0x70, 0xF1, 0xBA, 0x0D, 0xD8, 0x08, 0x18, 0xD9, 0x6E, 0x90, 0xDD, 0xA2, 0x86, 0x0F, 0x51, 0xEA, - 0x5F, 0x8A, 0x36, 0x20, 0xED, 0x46, 0x39, 0x30, 0xA3, 0x9C, 0x36, 0xBF, 0xFD, 0x27, 0xCC, 0x1D, - 0xE6, 0x47, 0x2C, 0x60, 0xDE, 0x8D, 0x96, 0xC6, 0xCC, 0x69, 0xB1, 0x18, 0xC8, 0x08, 0xD2, 0xAD, - 0x52, 0x93, 0x09, 0x43, 0x77, 0xF4, 0x5B, 0xBB, 0x2B, 0xAC, 0x18, 0x08, 0x37, 0xE0, 0x40, 0x00, - 0x00, 0x05, 0x3E, 0xFE, 0x06, 0x03, 0x3A, 0xB5, 0x3D, 0x1F, 0x4C, 0x40, 0xAE, 0xCE, 0x8E, 0xF3, - 0x4F, 0x42, 0x03, 0x1B, 0x84, 0xFF, 0x29, 0x2D, 0x7D, 0x31, 0x0F, 0x0A, 0xEA, 0x2F, 0x08, 0xC8, - 0x4F, 0xFA, 0x12, 0xEF, 0x6F, 0x65, 0x0E, 0x66, 0x0A, 0x1F, 0x69, 0x77, 0x13, 0x81, 0x95, 0x07, - 0x00, 0x4C, 0x8E, 0x07, 0x3B, 0x8C, 0xD0, 0x98, 0x2C, 0x1C, 0xD1, 0x36, 0x8E, 0x94, 0xF7, 0xC6, - 0x33, 0x27, 0x94, 0x4C, 0x8C, 0x7D, 0x3A, 0xB2, 0x30, 0x88, 0x60, 0x67, 0x63, 0x21, 0xF2, 0xE5, - 0x67, 0x20, 0x01, 0x04, 0xD7, 0x19, 0x1C, 0x3D, 0x79, 0x64, 0xCE, 0x0F, 0x28, 0x56, 0x88, 0xF1, - 0x81, 0x34, 0x18, 0x52, 0x5A, 0xF8, 0xAF, 0xB6, 0xAC, 0xFB, 0x15, 0x41, 0x34, 0x67, 0x11, 0x60, - 0x42, 0x18, 0x3D, 0x93, 0x41, 0x80, 0x0B, 0x83, 0x9C, 0x38, 0x60, 0x87, 0x3C, 0xE9, 0xFE, 0x04, - 0x28, 0xDF, 0xBE, 0x83, 0x92, 0x1B, 0x2B, 0x82, 0xA1, 0xA1, 0x88, 0xAA, 0xBF, 0xE9, 0xA4, 0x41, - 0x13, 0x82, 0x62, 0x2C, 0x11, 0x79, 0x4C, 0xCB, 0x7D, 0x6F, 0xC0, 0x9E, 0xAD, 0xF8, 0x54, 0x6A, - 0x75, 0x7E, 0xDF, 0x5E, 0x90, 0x91, 0xAD, 0x51, 0x61, 0x1D, 0x6E, 0x07, 0x50, 0xEE, 0x88, 0xD6, - 0x87, 0x28, 0xEF, 0xE1, 0xA5, 0xF6, 0x76, 0x4D, 0x85, 0xD0, 0x46, 0xD3, 0x76, 0x00, 0x40, 0x05, - 0x6C, 0x18, 0xDE, 0xFE, 0x20, 0x2B, 0xD7, 0x5F, 0x4D, 0xB5, 0x9E, 0x19, 0x08, 0x02, 0x87, 0xE4, - 0x89, 0x28, 0xF4, 0x7C, 0x6F, 0x86, 0x07, 0x03, 0xC2, 0xF3, 0x12, 0x30, 0x1A, 0x82, 0x34, 0x2F, - 0xFD, 0x0F, 0xEE, 0x0F, 0x6C, 0x44, 0x40, 0x7C, 0x4C, 0x3B, 0xF1, 0x9D, 0x45, 0x19, 0xC0, 0x00, - 0x00, 0x00, 0x6E, 0x8A, 0x8C, 0xC2, 0x80, 0xB4, 0xCF, 0x42, 0x4C, 0xC1, 0x40, 0x00, 0xC4, 0x60, - 0x6C, 0xC2, 0xE8, 0x44, 0xD2, 0x62, 0x34, 0x30, 0xFA, 0x31, 0xFC, 0x96, 0x32, 0x8C, 0xB5, 0x01, - 0x00, 0x06, 0x1B, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x87, 0x94, 0x90, 0x34, 0x4E, 0xC3, 0xB9, 0x4B, - 0x70, 0x31, 0x83, 0x79, 0x94, 0x14, 0x09, 0x60, 0x11, 0x40, 0xD3, 0x3C, 0xAE, 0xE5, 0x2D, 0xD0, - 0xBE, 0x8D, 0xA7, 0x30, 0x60, 0xA4, 0x30, 0x89, 0x66, 0x4B, 0x6D, 0x66, 0xD3, 0x14, 0x84, 0x26, - 0x85, 0x09, 0x2F, 0xDB, 0x29, 0x66, 0x4E, 0x18, 0xF1, 0x0D, 0xD5, 0x46, 0x83, 0x89, 0x7F, 0x32, - 0x65, 0x4E, 0x2C, 0xAC, 0x2A, 0x12, 0x71, 0xB7, 0x04, 0xF4, 0x10, 0x1B, 0x3B, 0x2A, 0x5E, 0xCA, - 0xC0, 0xF0, 0x29, 0x62, 0x76, 0xC5, 0x1B, 0x8C, 0x08, 0x65, 0x92, 0xD2, 0xC5, 0x58, 0x3B, 0xCF, - 0x16, 0xAD, 0xBB, 0x85, 0x01, 0xA1, 0x71, 0xA9, 0xD9, 0x2B, 0x3E, 0xAA, 0x55, 0x0D, 0xBA, 0x52, - 0x3A, 0x2B, 0xB2, 0x8E, 0xB5, 0xBF, 0x45, 0x96, 0x0E, 0x9F, 0x1D, 0x2A, 0xB8, 0x1F, 0xBF, 0xFB, - 0x15, 0x83, 0xA8, 0x2C, 0x15, 0x30, 0x80, 0x89, 0xC7, 0x48, 0x52, 0x4B, 0x0E, 0x9A, 0x49, 0xD3, - 0xE0, 0xF0, 0xA4, 0x14, 0x00, 0x50, 0x00, 0x00, 0x27, 0xCD, 0xE2, 0x40, 0x67, 0xD1, 0x4F, 0xD0, - 0xAE, 0x27, 0xD7, 0x6B, 0x7E, 0x0A, 0x93, 0xB6, 0x57, 0x66, 0x51, 0x05, 0xAE, 0xA3, 0x48, 0x38, - 0x28, 0x39, 0x10, 0x5C, 0xD8, 0x78, 0x70, 0x90, 0xE4, 0xCE, 0xE7, 0x84, 0x5F, 0x3D, 0x2A, 0x7B, - 0x49, 0x51, 0x2E, 0x22, 0x50, 0xC8, 0x1A, 0x6A, 0xE2, 0x30, 0x04, 0x4A, 0x33, 0xBC, 0x48, 0x08, - 0x0A, 0x0C, 0x5B, 0x03, 0x4C, 0x0C, 0x4E, 0xCD, 0x10, 0x1A, 0xCC, 0x91, 0x08, 0x4C, 0x3E, 0x17, - 0xCC, 0x9E, 0x38, 0x03, 0x01, 0x11, 0x40, 0x54, 0xC4, 0xC4, 0x34, 0xF9, 0x41, 0x1C, 0x1C, 0x18, - 0x61, 0x66, 0x55, 0x27, 0x10, 0xCC, 0xBE, 0x02, 0x13, 0x21, 0x83, 0x3C, 0xC0, 0xD8, 0x86, 0x9C, - 0x9E, 0x92, 0x97, 0xFD, 0x79, 0x47, 0x46, 0x48, 0x2F, 0xBB, 0x60, 0x78, 0x56, 0x53, 0xB4, 0xDA, - 0x98, 0xE3, 0x33, 0xA6, 0xF1, 0x29, 0x52, 0xB1, 0x7F, 0xBD, 0x4C, 0x68, 0x89, 0x65, 0x82, 0x24, - 0x1C, 0xD2, 0x31, 0xA0, 0xB4, 0x46, 0x5A, 0xC9, 0x1D, 0xF7, 0xCD, 0xF7, 0x7E, 0x69, 0x61, 0x98, - 0xE4, 0x62, 0x1D, 0xA3, 0xE7, 0xFF, 0xF4, 0x76, 0x27, 0x95, 0x26, 0x45, 0xFF, 0xBB, 0x40, 0xE6, - 0x39, 0xD0, 0x7E, 0xD1, 0x6E, 0x3D, 0xC9, 0x39, 0x37, 0xF9, 0xC1, 0x81, 0x01, 0x18, 0x21, 0x1E, - 0x00, 0x00, 0x19, 0x31, 0xE0, 0xFF, 0xE7, 0x91, 0x3B, 0x6B, 0xEA, 0x6A, 0x1A, 0x22, 0x30, 0xDA, - 0x13, 0x04, 0xE9, 0x24, 0xA9, 0x78, 0x28, 0x05, 0xC8, 0x4A, 0x59, 0x55, 0xCD, 0xC1, 0x61, 0xCC, - 0x32, 0x8B, 0x0C, 0x11, 0x13, 0x81, 0xD1, 0x21, 0xF6, 0xF7, 0x1F, 0xF5, 0xBF, 0x24, 0xA7, 0x2A, - 0xC0, 0x00, 0x00, 0x00, 0x8D, 0xD3, 0x8E, 0x85, 0x26, 0x63, 0x1B, 0x26, 0x06, 0x81, 0xA6, 0x03, - 0x83, 0x46, 0x0B, 0x13, 0xA7, 0x07, 0x09, 0x03, 0x46, 0xA1, 0x83, 0xC3, 0x91, 0x88, 0x26, 0xC1, - 0x8E, 0x80, 0xA0, 0x04, 0x1B, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x87, 0x14, 0x94, 0x34, 0xCE, 0xC3, - 0xB8, 0x7C, 0x40, 0x31, 0xE3, 0x79, 0xEB, 0x20, 0x06, 0x34, 0x11, 0xA4, 0xD5, 0x38, 0x0E, 0x65, - 0xF1, 0x00, 0xBD, 0x12, 0xE7, 0xF8, 0x2C, 0x08, 0x40, 0x30, 0x00, 0x66, 0x36, 0x6D, 0x7F, 0x08, - 0x57, 0xA0, 0x20, 0x40, 0x1E, 0x18, 0x54, 0x3E, 0x6B, 0xE0, 0xC1, 0xF0, 0x08, 0x4C, 0x8D, 0x2C, - 0xB5, 0x46, 0x3B, 0xB1, 0xF8, 0x24, 0x10, 0xB4, 0x01, 0xC3, 0x25, 0xE6, 0x37, 0x92, 0x7D, 0xFA, - 0x25, 0x53, 0x00, 0x6B, 0xD1, 0x86, 0x54, 0xBF, 0xD6, 0xE9, 0x6E, 0x06, 0x96, 0xC5, 0xD9, 0x6B, - 0x78, 0x97, 0x48, 0xDE, 0x66, 0x11, 0xC4, 0x6C, 0x3E, 0x56, 0xD1, 0x56, 0x1D, 0x36, 0xF4, 0xEC, - 0xB2, 0x40, 0xA1, 0x86, 0xE9, 0xCB, 0x1F, 0xFA, 0x5E, 0xEA, 0x58, 0x2D, 0x4A, 0x6B, 0xFF, 0xF1, - 0x98, 0xEF, 0x95, 0x11, 0x60, 0xBF, 0x45, 0xAD, 0xC7, 0x81, 0x77, 0xF6, 0x89, 0x05, 0x0F, 0xD2, - 0xDE, 0x50, 0xE2, 0xE2, 0x71, 0x56, 0x68, 0x14, 0x00, 0x20, 0x00, 0x40, 0x06, 0x81, 0x17, 0xF7, - 0xBF, 0xF6, 0x18, 0x58, 0x87, 0x25, 0x04, 0xC4, 0x13, 0x4B, 0x09, 0x63, 0xC9, 0xAA, 0xFD, 0xF0, - 0xEE, 0x78, 0x08, 0x08, 0xE4, 0x4C, 0x18, 0x48, 0x99, 0x32, 0x54, 0x31, 0x11, 0xCF, 0x5F, 0xB0, - 0x8A, 0xF5, 0x39, 0xF1, 0x05, 0x62, 0x79, 0x02, 0xB0, 0x12, 0x8A, 0x80, 0x0B, 0x82, 0x17, 0xB1, - 0x83, 0x42, 0x02, 0x31, 0x69, 0x7D, 0x4C, 0x8F, 0x07, 0x1A, 0x82, 0x19, 0xD5, 0xBA, 0x64, 0xD4, - 0x30, 0x1B, 0x4A, 0x60, 0xE2, 0x29, 0x84, 0x44, 0xA7, 0x56, 0x98, 0x1A, 0xCC, 0x44, 0xD6, 0x08, - 0x43, 0xA6, 0x47, 0x1C, 0xA0, 0xF3, 0x59, 0x11, 0x8B, 0xC6, 0xF8, 0xDB, 0x39, 0x30, 0xB4, 0x7C, - 0xDB, 0x81, 0x7B, 0x40, 0x01, 0x54, 0xC0, 0x64, 0x91, 0xA3, 0x1E, 0x13, 0x04, 0x83, 0xF1, 0x14, - 0x9A, 0x54, 0xAA, 0x41, 0xA4, 0xAD, 0xC5, 0xA4, 0xD6, 0xC8, 0x87, 0xAF, 0x0D, 0x86, 0x00, 0xB5, - 0x8B, 0xEE, 0x90, 0xE0, 0x64, 0x25, 0x2F, 0xC2, 0xC0, 0xAD, 0xC5, 0xAE, 0x94, 0xCB, 0x96, 0x8C, - 0xEF, 0x13, 0x3F, 0xC4, 0x68, 0x5F, 0x50, 0x16, 0xE1, 0x6F, 0xFF, 0xF3, 0x95, 0x6A, 0xF4, 0x6D, - 0x37, 0x96, 0x47, 0xD3, 0x9B, 0xC5, 0x31, 0xE1, 0xD7, 0x04, 0xB0, 0xEF, 0x56, 0x9E, 0x92, 0x16, - 0xD3, 0xD9, 0x88, 0x9A, 0x4D, 0xA2, 0x0A, 0x70, 0x00, 0x00, 0x00, 0x00, 0xA1, 0x05, 0x45, 0x52, - 0x5B, 0xC7, 0xFF, 0xD4, 0xCA, 0xCC, 0x48, 0x30, 0x04, 0x55, 0x07, 0x85, 0x6D, 0x4E, 0xE2, 0x1E, - 0xE6, 0x44, 0x2B, 0x1C, 0xC8, 0x00, 0xE6, 0x6A, 0x7F, 0xF7, 0x25, 0x22, 0x99, 0xFB, 0x71, 0x3B, - 0xC2, 0xD2, 0xA6, 0x96, 0x4E, 0x80, 0x00, 0x03, 0x5D, 0x81, 0x8C, 0x06, 0x17, 0x35, 0xB8, 0x2C, - 0xC9, 0x00, 0x73, 0x02, 0x10, 0x01, 0x29, 0x73, 0xF1, 0xBB, 0x8D, 0x3A, 0x09, 0x30, 0x9B, 0xE0, - 0x02, 0x46, 0x12, 0xDC, 0x82, 0x46, 0xE5, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x74, 0x84, 0x34, - 0xCE, 0x2B, 0x9A, 0x7B, 0x64, 0x2F, 0x46, 0x59, 0xC4, 0x14, 0xC2, 0x88, 0x52, 0x24, 0xD3, 0x38, - 0x0E, 0x61, 0xF2, 0xD0, 0xAE, 0x19, 0xA6, 0x94, 0x72, 0x8E, 0xA3, 0x01, 0x73, 0xA0, 0xD6, 0x0F, - 0x42, 0xC4, 0x39, 0x98, 0x42, 0x47, 0xC5, 0xA3, 0xCC, 0xA8, 0x01, 0x32, 0x44, 0xB2, 0xBD, 0xC8, - 0x11, 0x35, 0x27, 0xEC, 0x20, 0x3C, 0x90, 0x50, 0x39, 0xAC, 0x21, 0xC3, 0x11, 0x8B, 0x69, 0x30, - 0x22, 0x14, 0x85, 0x59, 0x22, 0x3A, 0xF6, 0x4E, 0xA0, 0x40, 0x06, 0xD6, 0xB2, 0x86, 0x37, 0xD3, - 0x31, 0xF0, 0xC0, 0xC5, 0xFA, 0x50, 0x02, 0xE2, 0x0D, 0x3D, 0xA4, 0xA1, 0x41, 0x84, 0x75, 0xBE, - 0x97, 0xD0, 0x97, 0x0D, 0xDB, 0x09, 0xE5, 0x16, 0x1E, 0xB2, 0xEB, 0x3B, 0x7D, 0xFF, 0xFE, 0x9E, - 0x55, 0x02, 0xA4, 0xFB, 0x73, 0x8A, 0x23, 0x85, 0xB9, 0x2C, 0xFC, 0x7C, 0xC1, 0xC1, 0x9C, 0xD9, - 0x58, 0xA4, 0xC1, 0x56, 0x8F, 0x44, 0x13, 0xD2, 0xC3, 0x72, 0x02, 0x00, 0x60, 0x00, 0x98, 0x48, - 0x7C, 0x68, 0x63, 0x7F, 0xEB, 0xD0, 0x8F, 0xE2, 0xF1, 0x56, 0x66, 0xF4, 0xE2, 0x3B, 0xB2, 0xD0, - 0x2C, 0xC7, 0xAC, 0xCE, 0x4D, 0xD1, 0x2E, 0x35, 0xDD, 0xBD, 0x9F, 0xA1, 0x5C, 0x8F, 0xD3, 0xFA, - 0xEF, 0x95, 0x9D, 0x46, 0xD0, 0xBB, 0xB8, 0xEE, 0x56, 0x5E, 0x87, 0xA4, 0x80, 0x93, 0x5F, 0x33, - 0x54, 0x2C, 0xC5, 0x06, 0x83, 0x07, 0x17, 0x4D, 0xF0, 0x36, 0x33, 0xF2, 0x9C, 0xCF, 0x0C, 0x93, - 0x37, 0xB3, 0xCC, 0x98, 0x47, 0x2A, 0x81, 0x8C, 0x10, 0x8A, 0x3D, 0x63, 0x74, 0xD0, 0x42, 0x93, - 0x00, 0x87, 0x0C, 0xAC, 0xBE, 0x30, 0x68, 0x15, 0x67, 0x97, 0x30, 0xC9, 0x82, 0x71, 0xA0, 0x23, - 0x77, 0x30, 0x48, 0xB4, 0xB6, 0x93, 0xC8, 0xDA, 0x79, 0x92, 0x7C, 0x38, 0x0A, 0x50, 0x1D, 0x97, - 0xFD, 0x1D, 0x0B, 0xE8, 0x7A, 0x29, 0x7F, 0x5C, 0x15, 0xF4, 0xBA, 0x5E, 0x4A, 0xEA, 0xAD, 0x7B, - 0x4F, 0x4B, 0x44, 0x6B, 0x62, 0x24, 0x9E, 0x4B, 0x58, 0x02, 0x11, 0x23, 0x97, 0x4A, 0x05, 0xF7, - 0x94, 0xC9, 0xCE, 0xDA, 0xC5, 0x11, 0xD4, 0xAC, 0x0A, 0xDD, 0xFF, 0xE5, 0x75, 0xFF, 0xFF, 0x7D, - 0xAD, 0xA1, 0x9D, 0x48, 0xAC, 0x2E, 0xAB, 0xB5, 0x49, 0x37, 0x3F, 0x8E, 0xA6, 0x6A, 0xAE, 0x9C, - 0xDF, 0x21, 0x26, 0x42, 0x84, 0xE8, 0x7C, 0xB6, 0x4F, 0x28, 0x22, 0x98, 0xD3, 0x48, 0xB7, 0xFF, - 0xE8, 0x36, 0x7E, 0x20, 0x30, 0xAE, 0x16, 0x20, 0x18, 0xD1, 0x8A, 0xE2, 0x62, 0x71, 0xDC, 0x82, - 0x80, 0xA1, 0x61, 0xAF, 0x3F, 0x9F, 0xA1, 0x1A, 0x9E, 0x8F, 0xFF, 0x38, 0x48, 0x4E, 0xEC, 0xE5, - 0x7E, 0x15, 0x07, 0x90, 0x82, 0x15, 0x80, 0x00, 0x00, 0x20, 0x77, 0x92, 0xA5, 0x32, 0x0D, 0xC6, - 0xC0, 0x30, 0x88, 0x81, 0x1D, 0x8C, 0xD2, 0xA3, 0x37, 0x81, 0xA4, 0x80, 0x7E, 0x6E, 0x84, 0xF1, - 0xC4, 0x81, 0x66, 0x0D, 0x25, 0x98, 0x9C, 0xFC, 0x63, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x8D, 0x14, - 0x7C, 0x34, 0xCE, 0x43, 0x99, 0x7B, 0xD0, 0x30, 0x06, 0x89, 0xB9, 0x15, 0x22, 0x96, 0x11, 0xD0, - 0xCF, 0x38, 0x0E, 0x65, 0xF1, 0x18, 0xBA, 0x17, 0xE5, 0x40, 0x60, 0x34, 0x71, 0xEB, 0x71, 0x8C, - 0x41, 0x83, 0xC0, 0xB3, 0x2A, 0xA9, 0x43, 0xDD, 0xC1, 0x93, 0x11, 0x00, 0x58, 0xF9, 0x93, 0x97, - 0xA1, 0xAB, 0x80, 0xE1, 0x4E, 0x19, 0x18, 0xA2, 0x20, 0x66, 0x59, 0x4A, 0x61, 0xB4, 0xE5, 0xD8, - 0xA1, 0xA5, 0x84, 0x16, 0xF2, 0x84, 0xBA, 0x41, 0x70, 0xD1, 0x10, 0x44, 0x1C, 0xBE, 0x32, 0x9D, - 0xEF, 0x3D, 0x05, 0x08, 0x88, 0x87, 0x4D, 0xCA, 0x05, 0x0E, 0x06, 0xAD, 0xE8, 0x69, 0xEF, 0xB2, - 0x57, 0x79, 0xE7, 0xE3, 0xFB, 0x32, 0xCE, 0xAB, 0xD4, 0x96, 0xFF, 0x1E, 0xBA, 0xFF, 0xFF, 0x7B, - 0xFB, 0xA2, 0x0B, 0x80, 0xF4, 0x0A, 0x79, 0x94, 0x86, 0x21, 0xCB, 0x27, 0xF2, 0x6A, 0xB2, 0xA0, - 0x16, 0x13, 0xCF, 0xD1, 0x2A, 0xA3, 0x35, 0xD2, 0x86, 0x64, 0x00, 0x03, 0x00, 0x20, 0x02, 0x2C, - 0x19, 0xFF, 0xFF, 0xFA, 0x73, 0x82, 0xE6, 0xD6, 0x55, 0x12, 0x8D, 0xE7, 0x43, 0x66, 0x6B, 0x7D, - 0xFF, 0x84, 0xE4, 0x8D, 0x28, 0x7F, 0xF5, 0x79, 0x0B, 0x55, 0xA2, 0xD9, 0xBF, 0xFD, 0x45, 0x45, - 0x4C, 0x2A, 0x02, 0xE8, 0x2B, 0x3B, 0x68, 0x47, 0x30, 0x96, 0x70, 0x50, 0x07, 0x0A, 0x05, 0xC0, - 0x56, 0xD3, 0x10, 0x07, 0x0C, 0x62, 0x07, 0x31, 0x7C, 0x2C, 0xC4, 0x03, 0x31, 0xA0, 0x51, 0x84, - 0x42, 0xC6, 0xAE, 0x03, 0x05, 0x01, 0x66, 0x1A, 0x03, 0x19, 0xB5, 0xFE, 0x62, 0x30, 0x81, 0x84, - 0x40, 0x66, 0x36, 0xBA, 0x93, 0x8C, 0x80, 0x84, 0x11, 0x61, 0x49, 0x93, 0x81, 0x68, 0xDA, 0xE3, - 0x19, 0xDE, 0xB9, 0xEE, 0xF1, 0x08, 0xA2, 0x42, 0xB3, 0x6B, 0x05, 0xD9, 0x7A, 0xD3, 0xD0, 0x01, - 0x29, 0x77, 0xC4, 0x66, 0x17, 0xE8, 0x98, 0x84, 0xC8, 0x86, 0x84, 0xA0, 0x68, 0x74, 0xEE, 0x89, - 0x40, 0x6B, 0x9E, 0x36, 0x9C, 0x09, 0x9A, 0xD8, 0x0F, 0x04, 0x01, 0xC9, 0x01, 0x45, 0x65, 0x96, - 0xA6, 0xAE, 0xBB, 0x39, 0x54, 0xB8, 0x83, 0x56, 0x68, 0x4D, 0x2B, 0x7B, 0xFF, 0xFF, 0xFF, 0xFF, - 0x2C, 0x6B, 0x0D, 0x8D, 0xCB, 0xE4, 0x91, 0x34, 0x84, 0xB6, 0xB0, 0xE1, 0x18, 0x6D, 0x44, 0x78, - 0xE2, 0xA9, 0x5E, 0x7F, 0xE1, 0x9C, 0xD1, 0x16, 0x72, 0x23, 0x7F, 0x69, 0x24, 0x99, 0x59, 0x22, - 0x58, 0x4D, 0x35, 0x0F, 0xA9, 0xDE, 0xA4, 0x9F, 0xA8, 0xE2, 0x65, 0x33, 0xCA, 0x4B, 0xF2, 0x21, - 0xA9, 0xB1, 0xA2, 0x09, 0x99, 0x4D, 0x3F, 0xFD, 0x65, 0xF3, 0x53, 0xAA, 0x5B, 0x58, 0xBA, 0xCA, - 0x76, 0x62, 0x71, 0x7D, 0xB0, 0x52, 0x55, 0xA0, 0x00, 0x07, 0x65, 0xE3, 0x01, 0xA3, 0x79, 0xAA, - 0xCB, 0x3E, 0x54, 0x04, 0x19, 0xA0, 0x00, 0x61, 0x90, 0x61, 0x82, 0x10, 0x86, 0x95, 0x85, 0x19, - 0x8C, 0xA6, 0x0E, 0x0E, 0x1A, 0x24, 0x74, 0x6A, 0x0D, 0x11, 0x59, 0xFF, 0xFB, 0x90, 0x64, 0x12, - 0x07, 0xF4, 0xA1, 0x33, 0xCD, 0xAB, 0x9A, 0x7B, 0xD0, 0x2D, 0x86, 0x99, 0x00, 0x0C, 0x0A, 0x1E, - 0x12, 0x48, 0xD1, 0x38, 0x0E, 0x65, 0x92, 0xC0, 0xBE, 0x94, 0xE2, 0x41, 0x80, 0x34, 0xB8, 0x0D, - 0x62, 0x18, 0xCA, 0x02, 0x7C, 0xD2, 0x69, 0x93, 0x86, 0x24, 0xD0, 0xC6, 0xED, 0x12, 0x5E, 0x83, - 0xC3, 0xB2, 0x8C, 0x1A, 0xA4, 0xF9, 0x1C, 0x12, 0x5A, 0xF4, 0xAF, 0x72, 0x41, 0xC4, 0x92, 0x11, - 0x84, 0x17, 0x7C, 0x3D, 0x3A, 0x2B, 0x22, 0x68, 0xA0, 0x38, 0xCC, 0x50, 0x74, 0x10, 0x08, 0x86, - 0x31, 0xD0, 0xE5, 0x69, 0x55, 0x19, 0x86, 0x95, 0x45, 0x32, 0x8C, 0x98, 0xC0, 0xCA, 0x88, 0xAA, - 0x90, 0x35, 0xE1, 0xB0, 0x62, 0xC7, 0x21, 0xEC, 0x3F, 0x54, 0xF0, 0x59, 0x36, 0xAA, 0x46, 0x7F, - 0xE1, 0xC4, 0xF0, 0x22, 0x7F, 0xE0, 0x64, 0xC7, 0x3F, 0xD8, 0x48, 0x30, 0x9A, 0x0F, 0x01, 0xB0, - 0x8F, 0x59, 0x90, 0xB9, 0x9D, 0x6E, 0x2B, 0x85, 0x65, 0x6C, 0x96, 0x81, 0x09, 0x43, 0x94, 0x51, - 0x57, 0x41, 0xE9, 0x29, 0xCB, 0x21, 0x1E, 0x90, 0x09, 0xCA, 0x6F, 0xF9, 0x11, 0xEA, 0x6F, 0xF9, - 0x30, 0xC4, 0x29, 0x03, 0xF0, 0x69, 0x0B, 0x80, 0x0B, 0x02, 0xE8, 0x16, 0xFA, 0xFF, 0x80, 0xC8, - 0xE2, 0xCD, 0x36, 0x8F, 0x39, 0x4D, 0x69, 0xD4, 0x79, 0xC7, 0x15, 0x1E, 0xB4, 0x45, 0x9E, 0x01, - 0x03, 0x46, 0x9A, 0x9B, 0x03, 0x80, 0xA3, 0x00, 0xB3, 0x00, 0x8F, 0x81, 0x27, 0xD3, 0x16, 0x86, - 0x0D, 0x1C, 0x50, 0x35, 0x4B, 0x30, 0xC6, 0x01, 0x73, 0x06, 0x1D, 0x4C, 0x9E, 0xCA, 0x39, 0xC1, - 0x48, 0x54, 0x46, 0x60, 0x33, 0x69, 0xA2, 0x6D, 0x80, 0x28, 0x51, 0x84, 0x00, 0xA5, 0x02, 0x13, - 0x26, 0x93, 0x43, 0x06, 0xC1, 0x50, 0x81, 0x92, 0x45, 0xE1, 0x02, 0x37, 0xCA, 0x01, 0x22, 0x29, - 0x2E, 0xD0, 0xA0, 0x33, 0x42, 0x82, 0xD4, 0x58, 0xC2, 0xC1, 0xBA, 0x21, 0x19, 0x79, 0x1F, 0xF8, - 0xA3, 0x2A, 0x05, 0x03, 0x71, 0xA4, 0x25, 0xC2, 0x12, 0x73, 0x83, 0x05, 0x99, 0x33, 0x49, 0x0A, - 0x06, 0x5D, 0x13, 0x38, 0xE7, 0xFE, 0x37, 0xF9, 0x32, 0x4F, 0x2D, 0x8F, 0xC3, 0x4B, 0x6D, 0xCC, - 0xA3, 0xE9, 0x94, 0x95, 0x98, 0x1B, 0x99, 0x9F, 0x3A, 0x58, 0xA9, 0x19, 0xE8, 0x2C, 0x72, 0x02, - 0x0E, 0x14, 0xA9, 0x4A, 0x69, 0xA8, 0x43, 0xBE, 0x68, 0xF4, 0x6E, 0x0D, 0x81, 0xAC, 0x7E, 0xF0, - 0x82, 0x52, 0x1C, 0x7C, 0xB1, 0xFE, 0x60, 0xB1, 0xD8, 0x32, 0x44, 0xAD, 0xFF, 0xD7, 0xFF, 0x4C, - 0xF0, 0x8D, 0x00, 0x91, 0x18, 0x51, 0x08, 0x1C, 0x91, 0xB0, 0x96, 0x52, 0x78, 0x9A, 0x00, 0xEB, - 0x2D, 0x6E, 0xB2, 0x70, 0x3A, 0x88, 0xC9, 0x7F, 0xFF, 0xFF, 0xF4, 0x7F, 0xFF, 0xFE, 0x85, 0x80, - 0x00, 0x00, 0x00, 0x04, 0x13, 0x88, 0xDC, 0x01, 0x15, 0x99, 0x4E, 0x36, 0x2C, 0x0F, 0x6C, 0xA0, - 0xD1, 0x49, 0xD7, 0xD2, 0x26, 0x33, 0x06, 0x01, 0x02, 0xE6, 0x2B, 0x8A, 0xFF, 0xFB, 0x92, 0x64, - 0x0E, 0x85, 0x34, 0x4D, 0x34, 0x4F, 0x5B, 0x99, 0x5C, 0x40, 0x31, 0x64, 0x98, 0xD0, 0x34, 0xD1, - 0x74, 0x11, 0x44, 0xD3, 0x3B, 0x0E, 0x65, 0x32, 0xC0, 0xC4, 0x9A, 0x65, 0x90, 0xD3, 0x1E, 0x08, - 0x80, 0x00, 0x63, 0xC5, 0x03, 0x15, 0x87, 0x0C, 0x93, 0x03, 0x31, 0xA8, 0x20, 0xC2, 0xC0, 0xF3, - 0x13, 0x6E, 0xCD, 0x0A, 0x0F, 0x30, 0x30, 0x11, 0xAF, 0x98, 0x08, 0xB0, 0x64, 0x04, 0x83, 0x80, - 0x88, 0x4C, 0x67, 0x9C, 0xD6, 0x32, 0x21, 0x31, 0xB6, 0x63, 0xA2, 0x30, 0x0E, 0x11, 0x5F, 0xD2, - 0xD5, 0x1B, 0xEE, 0x22, 0x91, 0x73, 0xA2, 0x1B, 0x83, 0x1D, 0xAD, 0x2B, 0x35, 0x02, 0xBE, 0xB4, - 0xD8, 0xA9, 0x53, 0x08, 0xB2, 0x69, 0x6A, 0xB2, 0x1D, 0xEB, 0x47, 0xBE, 0x4D, 0x40, 0xE9, 0x91, - 0xA1, 0x41, 0x1F, 0x94, 0x2F, 0xD4, 0xF8, 0x77, 0xF3, 0xA9, 0x16, 0xBC, 0x18, 0x92, 0xC8, 0x30, - 0x21, 0x4D, 0x13, 0x46, 0x28, 0x95, 0xAA, 0xB1, 0x98, 0xFE, 0x1F, 0x0E, 0x5C, 0x0F, 0x10, 0x22, - 0x9F, 0x52, 0x29, 0x12, 0x41, 0x78, 0x35, 0x7F, 0xF3, 0xC7, 0x99, 0x24, 0xC9, 0xEC, 0x5E, 0xFB, - 0xD6, 0xF7, 0x04, 0x34, 0x40, 0xE6, 0x8B, 0xDB, 0xF9, 0xD3, 0x74, 0x13, 0x7E, 0xA0, 0x97, 0x1B, - 0x05, 0xE9, 0xC4, 0x10, 0x5B, 0x4E, 0x0B, 0x40, 0xA1, 0x9F, 0x96, 0xFB, 0xBE, 0x1F, 0xC0, 0x00, - 0x35, 0xE4, 0x30, 0x2D, 0x21, 0x9F, 0x89, 0x01, 0x8D, 0xB3, 0x0F, 0x00, 0x0C, 0x20, 0x49, 0x31, - 0xAE, 0x88, 0xC8, 0x84, 0x43, 0x1B, 0x89, 0xCD, 0x14, 0x8F, 0x34, 0xE2, 0x30, 0x60, 0x80, 0x64, - 0xD0, 0xC1, 0x02, 0xE0, 0xDB, 0x63, 0xD2, 0xE0, 0x18, 0xD1, 0x66, 0x70, 0x57, 0x90, 0x39, 0xD8, - 0xED, 0x95, 0x46, 0x86, 0x59, 0x3D, 0x87, 0x0B, 0xD0, 0x46, 0x60, 0xE0, 0x79, 0xF4, 0x21, 0x76, - 0x8A, 0x0B, 0x10, 0x08, 0xFA, 0xBB, 0x85, 0x83, 0x40, 0x81, 0x31, 0x26, 0x48, 0x5F, 0xD3, 0x28, - 0x62, 0x61, 0x3B, 0xC9, 0x4D, 0xE8, 0x94, 0x6A, 0x97, 0x0A, 0x68, 0xEA, 0xEC, 0x30, 0x07, 0x0B, - 0x06, 0x2C, 0x5B, 0x31, 0x77, 0x18, 0xBF, 0xC4, 0x60, 0xA9, 0x20, 0x8C, 0x35, 0x49, 0x70, 0x7D, - 0xFF, 0xA0, 0x87, 0xFF, 0xFF, 0xFF, 0x96, 0xF9, 0x12, 0x34, 0x50, 0x4C, 0x06, 0xC1, 0x17, 0x18, - 0xCF, 0xB8, 0xA0, 0x22, 0xB1, 0x10, 0x81, 0xB9, 0x80, 0x18, 0x0E, 0x00, 0x1C, 0xC8, 0xE7, 0x52, - 0xDC, 0x0C, 0x01, 0x6A, 0xCF, 0xAF, 0xC2, 0xD8, 0x58, 0xE4, 0x02, 0x31, 0x89, 0xAF, 0x88, 0x07, - 0x8D, 0xD4, 0x54, 0x01, 0xC5, 0xA9, 0x3F, 0xFC, 0x20, 0x3C, 0xFE, 0xA4, 0xCF, 0xD8, 0x6E, 0x7C, - 0x71, 0xA8, 0xE5, 0x7F, 0xFF, 0xE8, 0xBF, 0xFC, 0x71, 0x95, 0xC0, 0x00, 0x00, 0x00, 0x10, 0x80, - 0x90, 0x59, 0x81, 0x60, 0xF1, 0x8A, 0x8A, 0x51, 0x80, 0x01, 0x91, 0x10, 0xB2, 0x23, 0x17, 0xCC, - 0x83, 0x87, 0x4C, 0x0D, 0x03, 0x0C, 0x74, 0x11, 0xCC, 0x51, 0x06, 0x4C, 0x9E, 0x3E, 0xFF, 0xFB, - 0x92, 0x64, 0x12, 0x07, 0x24, 0xA2, 0x34, 0x4E, 0x43, 0xB8, 0x7C, 0xB0, 0x31, 0x46, 0x99, 0xCB, - 0x29, 0x25, 0xB0, 0x10, 0xF4, 0xD3, 0x3A, 0xAE, 0x65, 0xF2, 0xD0, 0xC9, 0x16, 0xA7, 0x50, 0x90, - 0x9C, 0x98, 0x4C, 0x27, 0x0F, 0x8C, 0x0D, 0x0D, 0xCC, 0x41, 0x0E, 0x0D, 0xD5, 0x07, 0x40, 0x44, - 0x98, 0x24, 0x2E, 0x2A, 0x90, 0x26, 0x86, 0x05, 0x0B, 0x50, 0x20, 0x1A, 0x0A, 0x85, 0x06, 0x37, - 0x81, 0xAC, 0xB5, 0x13, 0x0C, 0x31, 0x4E, 0xA5, 0xAA, 0x30, 0x22, 0x37, 0x22, 0x7B, 0x80, 0xC8, - 0x06, 0x7F, 0x00, 0x8E, 0x05, 0x8C, 0x86, 0x16, 0x7F, 0x29, 0xA4, 0xC8, 0x7C, 0xAD, 0xEF, 0x99, - 0x50, 0xA4, 0x02, 0x14, 0xAA, 0xA1, 0x80, 0x20, 0x7A, 0x29, 0x7C, 0xF1, 0x77, 0xD8, 0x52, 0x6D, - 0xEB, 0xCA, 0x12, 0x8E, 0x8C, 0x67, 0xBE, 0xFE, 0x4D, 0xE6, 0xCA, 0x53, 0xFF, 0xFF, 0xFF, 0xDE, - 0x8B, 0xA5, 0x71, 0x7A, 0x80, 0x45, 0x21, 0x44, 0x81, 0x53, 0xBF, 0x4C, 0xDD, 0x4C, 0x7E, 0xB1, - 0x27, 0x99, 0x00, 0x00, 0x0E, 0xC0, 0x00, 0x45, 0x16, 0xA7, 0xBD, 0xC3, 0x22, 0xDB, 0xD3, 0x43, - 0x08, 0xDA, 0x50, 0x43, 0xD0, 0x45, 0xB9, 0xE3, 0x03, 0x7E, 0x5C, 0x4F, 0x9F, 0x91, 0x93, 0xEF, - 0x9C, 0xF1, 0x20, 0x80, 0xFE, 0xA2, 0x15, 0xC8, 0xB3, 0x71, 0x2B, 0x7F, 0xFD, 0x4E, 0x87, 0x74, - 0x6F, 0xF5, 0x17, 0x68, 0x19, 0x34, 0x02, 0x5F, 0xC3, 0x32, 0xC5, 0x0D, 0x34, 0x28, 0x08, 0x11, - 0x18, 0x1C, 0x1C, 0x74, 0x88, 0xA1, 0xB7, 0x42, 0x26, 0x3C, 0x46, 0x18, 0x80, 0x2C, 0x0D, 0x9B, - 0x06, 0x21, 0x0C, 0x2A, 0x33, 0x32, 0x68, 0x84, 0xE3, 0x8C, 0xC6, 0x74, 0x01, 0x1B, 0x27, 0xF1, - 0x90, 0x8E, 0xF1, 0xB5, 0x04, 0x21, 0x04, 0x9A, 0xDC, 0x0E, 0x8B, 0x64, 0x80, 0x31, 0x58, 0x4E, - 0x50, 0x60, 0xAA, 0x70, 0xA5, 0x62, 0x49, 0x41, 0xF2, 0xA5, 0x30, 0x28, 0x49, 0xF5, 0x19, 0x2D, - 0x30, 0x35, 0x7A, 0x9C, 0x12, 0x1C, 0x57, 0x2D, 0xE5, 0xFA, 0x71, 0x03, 0xB7, 0x45, 0x39, 0x11, - 0x76, 0x87, 0x82, 0x55, 0xFF, 0x88, 0x10, 0x4B, 0x6A, 0xAD, 0xB1, 0xBD, 0x85, 0x6F, 0x57, 0xB5, - 0x1F, 0xC6, 0x38, 0xE2, 0x7F, 0xFF, 0xFF, 0xDD, 0x7A, 0xB1, 0x32, 0x73, 0x3F, 0x2E, 0xED, 0xE2, - 0x3E, 0xA0, 0x8F, 0x78, 0xCD, 0x56, 0xCF, 0x45, 0x98, 0xC9, 0x5D, 0x20, 0x10, 0x5D, 0x00, 0x16, - 0x41, 0x2E, 0x98, 0x92, 0x4C, 0x4E, 0xBA, 0x63, 0x71, 0x6B, 0x47, 0x86, 0xCE, 0x84, 0xE5, 0x42, - 0xC4, 0x32, 0xB8, 0xD4, 0x7A, 0x8C, 0x44, 0x6D, 0xF5, 0x1B, 0x0E, 0x30, 0x8E, 0x5F, 0xCD, 0x43, - 0x5D, 0x52, 0xDF, 0xBF, 0xFE, 0x38, 0x55, 0xD6, 0x54, 0x48, 0x4A, 0x4E, 0xA3, 0x2A, 0xC0, 0x00, - 0x00, 0x00, 0x62, 0x20, 0x10, 0x10, 0x70, 0x18, 0x11, 0x83, 0x20, 0xA7, 0xB4, 0xB6, 0xC6, 0x0A, - 0x08, 0xC1, 0x59, 0x90, 0xC7, 0x00, 0x18, 0xC4, 0x70, 0xCC, 0xC0, 0xA0, 0x04, 0xC3, 0xF4, 0x04, - 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x34, 0x87, 0x34, 0xCE, 0xC3, 0xBA, 0x7B, 0xD0, 0x2F, 0x66, - 0x89, 0xB4, 0x19, 0x05, 0x0E, 0x11, 0xA8, 0xD1, 0x3A, 0x0E, 0x6F, 0x09, 0x40, 0xBD, 0x19, 0x66, - 0x50, 0xA3, 0x2A, 0x89, 0xC2, 0x60, 0x90, 0xC0, 0xD1, 0x0C, 0x58, 0x01, 0x34, 0x14, 0x9D, 0x30, - 0x50, 0x10, 0x10, 0x81, 0x46, 0x69, 0x59, 0xF3, 0xE8, 0xDF, 0x16, 0x00, 0x00, 0x4A, 0x9D, 0x4A, - 0xCD, 0x95, 0xD8, 0x6B, 0x81, 0xDC, 0xA9, 0x9C, 0x50, 0xA9, 0x30, 0x70, 0x0B, 0x79, 0x29, 0x41, - 0x40, 0xA8, 0x9A, 0xF5, 0x05, 0x1C, 0x7B, 0x6B, 0xBC, 0x85, 0xF9, 0x6C, 0xF8, 0x6A, 0xED, 0xDA, - 0xEC, 0x80, 0x18, 0x81, 0x5B, 0xA3, 0xE9, 0x10, 0x0E, 0x49, 0x4F, 0xAC, 0x37, 0x40, 0x3D, 0xD5, - 0x92, 0x59, 0x7F, 0x17, 0x91, 0xAA, 0x2D, 0x61, 0xB5, 0xB8, 0xFF, 0xFF, 0xFF, 0xCA, 0xA6, 0x31, - 0xEF, 0x2A, 0x68, 0x2E, 0xD1, 0x30, 0x8D, 0x00, 0x78, 0x67, 0x19, 0x2B, 0x33, 0x05, 0x90, 0x87, - 0x9A, 0x0F, 0x74, 0x88, 0x00, 0x76, 0x28, 0x70, 0x68, 0xE4, 0x54, 0xCF, 0x21, 0x76, 0x5F, 0x9F, - 0x01, 0xB5, 0xDE, 0xB1, 0x68, 0x4C, 0x14, 0x13, 0x1A, 0x75, 0x01, 0x4B, 0x72, 0x87, 0xBE, 0x8A, - 0xA0, 0x59, 0xCD, 0xFC, 0x9C, 0xBF, 0x41, 0xBF, 0xFA, 0x19, 0xE2, 0x26, 0x1A, 0x93, 0x6A, 0xD9, - 0xD8, 0x49, 0xD1, 0x64, 0xBF, 0x42, 0x82, 0xD3, 0x0A, 0xD0, 0x4D, 0x0C, 0x17, 0x0E, 0x07, 0x18, - 0xF4, 0x56, 0x6F, 0x5A, 0x99, 0xC2, 0x00, 0x46, 0x54, 0x3C, 0x18, 0x39, 0xF1, 0xDD, 0x04, 0x98, - 0x50, 0xB0, 0xC1, 0x39, 0x87, 0x09, 0x1F, 0xF4, 0x12, 0xFD, 0x53, 0x23, 0x00, 0x04, 0x3A, 0xE2, - 0xF0, 0x81, 0x96, 0xA6, 0x61, 0x86, 0x06, 0xD4, 0x82, 0xDC, 0x1E, 0x70, 0xA1, 0x20, 0x38, 0x1A, - 0x2A, 0x82, 0xE2, 0x30, 0xD2, 0x32, 0xDB, 0x78, 0x04, 0x5C, 0x6B, 0xDC, 0x20, 0x91, 0x7E, 0x14, - 0xF4, 0xC2, 0x70, 0x08, 0x49, 0x2A, 0xDE, 0x74, 0xFC, 0xA8, 0x48, 0x23, 0x43, 0xD5, 0xEC, 0xC3, - 0xF4, 0x03, 0x3E, 0xB7, 0xFF, 0x13, 0xFA, 0xCF, 0xCD, 0xCE, 0x41, 0xB7, 0xBF, 0x6E, 0xF4, 0x9B, - 0x75, 0x6D, 0x59, 0xF9, 0xCF, 0xEF, 0xF3, 0x96, 0xF1, 0x7D, 0xE3, 0x1F, 0x61, 0x87, 0xB4, 0xAA, - 0x17, 0xA9, 0x76, 0x30, 0xD9, 0xE9, 0x42, 0xC3, 0xBD, 0xBD, 0x92, 0x27, 0xC4, 0x3F, 0x43, 0xA0, - 0x00, 0x02, 0x31, 0x05, 0x89, 0x71, 0x78, 0x68, 0x64, 0xE0, 0x25, 0xB7, 0x67, 0x43, 0xBE, 0xBC, - 0x62, 0x21, 0x8C, 0x40, 0xB8, 0x42, 0xC4, 0x29, 0x12, 0xE4, 0xC5, 0x75, 0x1F, 0xBE, 0x40, 0x0A, - 0x0C, 0x13, 0x5B, 0xFF, 0xA3, 0xA3, 0x66, 0x37, 0x6D, 0xFF, 0xD7, 0xFE, 0xA5, 0x5A, 0x9E, 0x80, - 0x00, 0x04, 0x32, 0xC2, 0x84, 0x01, 0x21, 0x80, 0x4C, 0x99, 0x8A, 0x20, 0xDA, 0xA5, 0x30, 0x9C, - 0x36, 0x36, 0xA2, 0x1F, 0x32, 0x30, 0x33, 0x78, 0x7B, 0x34, 0xD3, 0x73, 0xB3, 0x3E, 0x33, 0x54, - 0xA3, 0x06, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x87, 0x34, 0xAC, 0x34, 0x4E, 0x2B, 0xBB, 0xC9, 0xD4, - 0x2F, 0x26, 0x99, 0xB9, 0x29, 0x22, 0xA2, 0x92, 0x18, 0xD1, 0x38, 0x0E, 0xE9, 0xEB, 0xC0, 0xBA, - 0x8E, 0xE5, 0x60, 0xD0, 0x1D, 0x50, 0x5F, 0x36, 0x61, 0x43, 0xD9, 0x51, 0x03, 0x06, 0x20, 0x9C, - 0x2A, 0xA4, 0x6E, 0xE6, 0xA0, 0x60, 0x66, 0x72, 0x2A, 0xB4, 0x67, 0x20, 0xAA, 0x49, 0xF4, 0x1D, - 0xD9, 0x31, 0x5B, 0x8A, 0xED, 0x15, 0x25, 0x3C, 0x2B, 0x42, 0x0E, 0x32, 0x69, 0x22, 0xA2, 0xAC, - 0x00, 0x9D, 0x7C, 0x9B, 0x94, 0x25, 0x40, 0x5F, 0x2E, 0x33, 0x37, 0xBE, 0x9B, 0x01, 0xD3, 0x04, - 0x97, 0x79, 0xAB, 0xA3, 0x78, 0x41, 0xD6, 0xE4, 0xAD, 0x0F, 0x2A, 0x2C, 0x9B, 0x8D, 0x3D, 0x4C, - 0x5E, 0x49, 0xDF, 0xBA, 0xEE, 0xD9, 0xB1, 0x04, 0xDA, 0xCB, 0xDE, 0xBB, 0x7F, 0xAB, 0xBE, 0xFA, - 0x4F, 0xAF, 0x99, 0x2C, 0x03, 0x2A, 0x48, 0x55, 0xCB, 0x3C, 0xA3, 0xCF, 0x4B, 0x76, 0xC9, 0xCB, - 0xC6, 0x93, 0xAD, 0x89, 0xFA, 0xAA, 0xB3, 0x1D, 0xB0, 0x00, 0xC3, 0x00, 0x0C, 0x02, 0x85, 0xF2, - 0x00, 0xD7, 0x2A, 0x14, 0x88, 0xBF, 0xFD, 0xBC, 0xA8, 0xC0, 0xBE, 0x26, 0x0C, 0x37, 0xCE, 0x03, - 0xB6, 0x80, 0x9D, 0x0C, 0x7A, 0x95, 0xF7, 0x01, 0x41, 0xCF, 0x06, 0xFF, 0x45, 0xF6, 0xA9, 0x8F, - 0xA6, 0xAD, 0xFF, 0xFE, 0xB5, 0xB9, 0x44, 0xBB, 0xF4, 0x91, 0x05, 0xDE, 0x32, 0x40, 0xCB, 0x33, - 0x6C, 0x09, 0x31, 0x60, 0x05, 0x30, 0x58, 0x53, 0x33, 0xCE, 0x30, 0x31, 0x5C, 0x2A, 0x30, 0x6C, - 0x46, 0x30, 0xB8, 0x10, 0x33, 0x40, 0x2D, 0x32, 0xB7, 0x4C, 0x74, 0x51, 0x82, 0x06, 0xE5, 0x20, - 0x70, 0x95, 0x88, 0x04, 0xA8, 0x7E, 0xC8, 0x34, 0x3A, 0x40, 0x0C, 0xC0, 0x56, 0xE7, 0x7D, 0xA8, - 0x05, 0x43, 0x2F, 0x76, 0x08, 0xA1, 0xE4, 0x03, 0xD5, 0x1D, 0xA4, 0x1F, 0x28, 0x50, 0xDC, 0x5A, - 0x18, 0x80, 0x73, 0x91, 0x4F, 0x30, 0x8C, 0xCB, 0x8B, 0x1B, 0x0C, 0x6E, 0x35, 0xBA, 0x65, 0xE0, - 0xE0, 0x48, 0x90, 0xE0, 0x60, 0x0C, 0xBC, 0x2F, 0x14, 0x82, 0xD1, 0x3D, 0xA4, 0x66, 0x5D, 0xBA, - 0x75, 0x05, 0x96, 0xDE, 0x37, 0x52, 0x1F, 0xAA, 0x87, 0x98, 0x4A, 0xAD, 0x7B, 0xAD, 0x51, 0xA5, - 0x3E, 0x4E, 0x95, 0xC9, 0x92, 0x14, 0x82, 0x44, 0x16, 0x30, 0x6D, 0x1F, 0x82, 0x51, 0x60, 0x5B, - 0x5C, 0x31, 0xB5, 0xC2, 0x1E, 0x86, 0xAF, 0x9D, 0x00, 0x08, 0x04, 0x4A, 0x8B, 0x71, 0x06, 0x14, - 0x52, 0xB0, 0x4F, 0xCD, 0x3A, 0xF1, 0x16, 0x36, 0x04, 0x18, 0x1E, 0x02, 0x4C, 0x04, 0x80, 0x28, - 0x34, 0x11, 0x0B, 0xD3, 0xB9, 0xC3, 0x8F, 0x47, 0x1D, 0x12, 0xA2, 0x10, 0x43, 0x83, 0x55, 0xA4, - 0x5A, 0x59, 0x82, 0x5F, 0xF9, 0x15, 0x11, 0x6E, 0x44, 0xA0, 0x38, 0x04, 0x36, 0x32, 0x12, 0xC8, - 0x31, 0xA8, 0x34, 0x30, 0x08, 0x1F, 0x30, 0x10, 0x85, 0x34, 0x81, 0x3D, 0x3E, 0x0E, 0x0E, 0xA9, - 0x10, 0x30, 0x83, 0x42, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x8F, 0xE4, 0x5F, 0x33, 0xCE, 0x03, 0xBA, - 0xC1, 0xB2, 0x33, 0x86, 0x89, 0x01, 0x15, 0x27, 0x92, 0x12, 0x08, 0xD3, 0x34, 0x0E, 0xEB, 0x26, - 0x80, 0xBF, 0x93, 0x25, 0xC0, 0x60, 0x24, 0x20, 0x34, 0x23, 0x4A, 0xB8, 0x35, 0xC7, 0xC2, 0xF0, - 0xD5, 0xD1, 0x72, 0x4E, 0xAE, 0x2E, 0x12, 0x5A, 0xAD, 0xE3, 0x19, 0x00, 0xCE, 0x95, 0xB8, 0xEA, - 0x26, 0xAE, 0xA0, 0x11, 0xC2, 0x93, 0xED, 0x55, 0xE1, 0x46, 0x04, 0xBE, 0x89, 0xF5, 0x01, 0x05, - 0xC0, 0x2D, 0x0A, 0x2B, 0x2D, 0x26, 0x8A, 0xED, 0xE9, 0x04, 0xEC, 0xBA, 0x38, 0xB4, 0x91, 0x5A, - 0x19, 0x1D, 0x21, 0x71, 0x9B, 0x45, 0x66, 0x49, 0x57, 0x16, 0x3F, 0xFC, 0xF8, 0x26, 0x8A, 0x92, - 0x52, 0xFD, 0x61, 0x47, 0x37, 0x5A, 0x31, 0x33, 0x52, 0x0E, 0x9C, 0xA6, 0xB5, 0xF8, 0xCE, 0x7C, - 0x56, 0x5D, 0x41, 0x4E, 0xFA, 0xC4, 0x1F, 0xF9, 0x42, 0xC5, 0x87, 0x71, 0x75, 0xA4, 0xD2, 0xBE, - 0xE3, 0x94, 0x7A, 0x35, 0x18, 0x9A, 0x18, 0x08, 0x38, 0x3A, 0x54, 0x3A, 0x05, 0x2B, 0x28, 0x02, - 0x2B, 0xA9, 0xEA, 0x45, 0x7C, 0x94, 0x01, 0x0F, 0xF5, 0xA6, 0x08, 0x82, 0x2C, 0xB0, 0xD5, 0xCC, - 0x32, 0xDE, 0xCC, 0x4D, 0xB9, 0x83, 0x23, 0xA2, 0x28, 0x85, 0x17, 0x9A, 0xDD, 0x68, 0x11, 0x87, - 0x20, 0x2C, 0x09, 0x3F, 0xFE, 0xC6, 0x7F, 0x9A, 0xD3, 0x46, 0x8B, 0x14, 0x1A, 0x01, 0x18, 0xC0, - 0x36, 0x1C, 0x46, 0xC9, 0x9B, 0x10, 0x13, 0x89, 0x0D, 0x62, 0x21, 0x94, 0xD6, 0xD1, 0xA8, 0xD2, - 0xFF, 0x36, 0xAA, 0x81, 0x01, 0x4D, 0xC8, 0x83, 0x43, 0x60, 0xD3, 0x8B, 0x3A, 0xD9, 0x03, 0x98, - 0x3A, 0xD0, 0x05, 0x50, 0x77, 0xB6, 0xDE, 0xCB, 0x44, 0x08, 0xA0, 0x95, 0x11, 0xC9, 0x80, 0x65, - 0x4D, 0x29, 0xA6, 0xA7, 0xA0, 0x39, 0x80, 0x53, 0x4B, 0x51, 0xC8, 0x07, 0x04, 0x05, 0x09, 0x37, - 0x9A, 0xAA, 0x7C, 0x87, 0x41, 0x20, 0xEB, 0x0B, 0x91, 0x65, 0x5E, 0x05, 0xA5, 0x53, 0x07, 0x3D, - 0x98, 0xA0, 0xFA, 0x68, 0xAF, 0x86, 0x34, 0xC3, 0xC4, 0x20, 0x40, 0x2C, 0xF9, 0xAB, 0x5A, 0xBB, - 0x23, 0x8C, 0xB3, 0x9B, 0xB3, 0x30, 0xCC, 0xA1, 0xFC, 0xA5, 0x56, 0xC6, 0x21, 0xD6, 0xC4, 0xBF, - 0xE4, 0x1F, 0xBF, 0xEE, 0xA6, 0xA0, 0xFA, 0xDF, 0x9C, 0x26, 0x0B, 0xBF, 0x1A, 0x86, 0x5C, 0x17, - 0x86, 0x1D, 0x9D, 0xCF, 0x5F, 0xDA, 0x97, 0x21, 0x59, 0x55, 0xE0, 0xB0, 0xFF, 0xD0, 0x20, 0x9A, - 0xE2, 0x83, 0x15, 0x19, 0x5D, 0xA9, 0x17, 0xFF, 0xE4, 0x61, 0x22, 0xAF, 0xE5, 0x02, 0x86, 0x2D, - 0x1E, 0xFF, 0xE9, 0x5B, 0xCC, 0xF3, 0x6C, 0x86, 0x56, 0x6D, 0x75, 0xE5, 0x9E, 0xA1, 0x9E, 0xA0, - 0x40, 0x61, 0x48, 0xCB, 0x59, 0xFC, 0xBB, 0xBA, 0x84, 0x21, 0x5A, 0x80, 0x00, 0x00, 0x00, 0x1C, - 0x1F, 0x76, 0xE0, 0x0E, 0x37, 0x9D, 0xD3, 0x7A, 0x28, 0x37, 0x31, 0x58, 0x00, 0x84, 0x5E, 0x64, - 0xD2, 0x59, 0x80, 0x05, 0xA6, 0x26, 0xFF, 0xFB, 0x92, 0x64, 0x0D, 0x86, 0x04, 0x13, 0x34, 0x4E, - 0xCB, 0x99, 0x62, 0xF4, 0x32, 0x24, 0x29, 0xC9, 0x1D, 0x26, 0x60, 0x12, 0xE8, 0xD3, 0x30, 0x0E, - 0xEF, 0x42, 0x80, 0xC4, 0x9A, 0x66, 0xF4, 0x31, 0x1A, 0xA8, 0x05, 0x88, 0xC1, 0x2B, 0x9C, 0xD1, - 0x08, 0xC8, 0x8C, 0xF2, 0x94, 0x08, 0x91, 0x82, 0x20, 0x29, 0xA2, 0x2D, 0x15, 0x6D, 0xE4, 0x24, - 0x8F, 0x0A, 0xE0, 0x3F, 0xAF, 0xD5, 0xE7, 0x71, 0xB9, 0x48, 0x97, 0x5B, 0x6E, 0xC1, 0x56, 0x9D, - 0x22, 0x62, 0x38, 0x23, 0x24, 0x91, 0x03, 0x20, 0xEB, 0x81, 0x3D, 0xAD, 0x40, 0xF9, 0x45, 0x25, - 0x8E, 0xC0, 0xF0, 0x10, 0x3C, 0x81, 0x99, 0x3F, 0x42, 0xC0, 0xA4, 0x09, 0x19, 0x37, 0xAD, 0x79, - 0x28, 0xD2, 0x54, 0x97, 0x84, 0x30, 0x7C, 0x75, 0x25, 0x16, 0x8E, 0x95, 0x56, 0x66, 0x76, 0x65, - 0xDB, 0xED, 0x27, 0xB6, 0xA8, 0x41, 0xC1, 0x63, 0xBA, 0x76, 0x6E, 0x74, 0xDB, 0xDA, 0xE7, 0xFF, - 0xA9, 0xF2, 0x00, 0x80, 0x02, 0x04, 0x00, 0x64, 0xB9, 0xFF, 0xFD, 0x06, 0xA0, 0x65, 0x04, 0x68, - 0xB8, 0x50, 0xC5, 0xBB, 0x13, 0x87, 0x35, 0x44, 0x8E, 0xA3, 0x0E, 0x4B, 0x1E, 0x73, 0xFC, 0x24, - 0x52, 0x47, 0x9F, 0xD1, 0x2B, 0x21, 0x13, 0x76, 0x77, 0xF3, 0x13, 0xEF, 0x0B, 0x03, 0x41, 0x53, - 0xBF, 0xAB, 0xE0, 0x24, 0xBE, 0x0B, 0x03, 0xE4, 0x06, 0xF1, 0xE7, 0xAD, 0x61, 0xDC, 0x87, 0x18, - 0xA9, 0xA1, 0xA5, 0x5C, 0x1A, 0x0D, 0x99, 0x31, 0x09, 0xCE, 0xBC, 0x07, 0xAD, 0x35, 0x45, 0xCE, - 0x63, 0x43, 0x55, 0x50, 0xD0, 0x3C, 0x05, 0x72, 0x11, 0x00, 0x33, 0xA7, 0x03, 0x16, 0x8D, 0x0D, - 0x8F, 0x33, 0xC1, 0x80, 0x08, 0xC8, 0x62, 0x8A, 0x87, 0x11, 0x47, 0x44, 0xF4, 0x19, 0x1A, 0x60, - 0x00, 0x8B, 0x00, 0x18, 0x02, 0x2C, 0x0C, 0x18, 0x1C, 0x79, 0x8B, 0x5B, 0x0E, 0x16, 0x64, 0x64, - 0xA9, 0x16, 0xAD, 0x2F, 0x1D, 0x0D, 0x0E, 0x29, 0x9D, 0x33, 0x10, 0x8D, 0x25, 0xF3, 0x86, 0x85, - 0x40, 0x11, 0x04, 0xC1, 0xA7, 0x9D, 0x78, 0x1A, 0xEA, 0x6B, 0x35, 0xE8, 0xCB, 0xF5, 0x61, 0xCC, - 0xB4, 0xCB, 0xA9, 0xDE, 0x47, 0x29, 0x99, 0x46, 0x5B, 0x8A, 0x85, 0x53, 0x3C, 0xB0, 0xE5, 0x2C, - 0x31, 0x7F, 0xFF, 0x73, 0x15, 0x6C, 0x65, 0x0C, 0x47, 0xAF, 0xE5, 0x0E, 0x5A, 0x92, 0x2B, 0x1A, - 0xCD, 0x9A, 0x9F, 0xEC, 0xCD, 0x4E, 0xFD, 0xDA, 0x3D, 0x4E, 0xF4, 0x00, 0x00, 0xA0, 0x00, 0x00, - 0x01, 0x70, 0x01, 0xB8, 0x07, 0xFF, 0xFF, 0xF0, 0x18, 0xCC, 0x8C, 0xEA, 0xEA, 0xDD, 0x92, 0x56, - 0x7C, 0xCD, 0xD6, 0xAD, 0xEA, 0xEA, 0x5A, 0x2A, 0x5D, 0x7C, 0x55, 0xD6, 0xB4, 0x43, 0xFF, 0x38, - 0x44, 0x90, 0x45, 0x04, 0x48, 0xD9, 0x3D, 0x20, 0x2C, 0x2D, 0x47, 0xA7, 0x4F, 0xD7, 0x80, 0xC5, - 0x23, 0x40, 0x1D, 0x98, 0xCB, 0x85, 0x73, 0x13, 0x08, 0x4D, 0xC6, 0xB4, 0x33, 0x88, 0xB8, 0x14, - 0x6E, 0x37, 0xC3, 0x04, 0xDA, 0x05, 0x03, 0x1D, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x07, 0xA4, 0x8C, - 0x34, 0xCC, 0x03, 0x9A, 0x7A, 0x70, 0x33, 0x04, 0xD9, 0x9B, 0x14, 0xC3, 0x76, 0x10, 0xD8, 0xD1, - 0x32, 0xAE, 0x69, 0xE9, 0xC0, 0xC4, 0x16, 0x64, 0x80, 0x53, 0x1D, 0xF0, 0x32, 0x79, 0xC4, 0x79, - 0x0D, 0x18, 0xB3, 0x99, 0x4C, 0x39, 0x39, 0x9D, 0x9C, 0x06, 0x42, 0x50, 0x33, 0x26, 0x74, 0x0E, - 0x68, 0x0E, 0x35, 0x13, 0x56, 0xB0, 0x80, 0x46, 0x20, 0x80, 0x10, 0x2A, 0x18, 0x03, 0x87, 0x91, - 0x26, 0x32, 0xA4, 0x50, 0xA0, 0xD0, 0x8F, 0x2F, 0x00, 0x72, 0x53, 0x14, 0x79, 0x89, 0x32, 0x87, - 0x21, 0xA1, 0x31, 0x55, 0xF0, 0xAC, 0x07, 0x93, 0x88, 0x91, 0x0F, 0x50, 0xB0, 0xA9, 0x90, 0xE4, - 0xFD, 0x86, 0x20, 0xDE, 0x1D, 0xEB, 0x0E, 0x02, 0xFD, 0xB9, 0x53, 0x53, 0x28, 0xD9, 0x31, 0xCB, - 0xE9, 0xFF, 0x2A, 0x2C, 0xE8, 0x26, 0xAF, 0x99, 0xA1, 0x43, 0x9F, 0xFC, 0xD9, 0xBB, 0xF5, 0x5A, - 0x72, 0x12, 0xF3, 0x45, 0x57, 0x6D, 0xD0, 0x5B, 0x51, 0xD6, 0xD1, 0xB5, 0x8B, 0xA1, 0xD1, 0xEC, - 0xE1, 0x40, 0x00, 0x02, 0xB0, 0x00, 0x10, 0xA8, 0x05, 0xFF, 0xE6, 0xB1, 0xB9, 0xE8, 0xD0, 0x9F, - 0x85, 0x92, 0xFB, 0x0B, 0x02, 0x1B, 0xBF, 0xFF, 0xC1, 0xC5, 0x0C, 0x28, 0xF1, 0x06, 0xBC, 0xA6, - 0xC1, 0xD7, 0x6C, 0x1D, 0x33, 0xF1, 0x49, 0xA0, 0xBB, 0x4F, 0xA3, 0x4A, 0x95, 0x58, 0x48, 0x46, - 0x0E, 0xA5, 0x17, 0xBE, 0x98, 0x1F, 0xD5, 0x52, 0x30, 0x41, 0x94, 0xCD, 0x8A, 0x33, 0x04, 0x00, - 0x8C, 0x80, 0x23, 0x33, 0x90, 0xC8, 0xE4, 0x25, 0x23, 0x00, 0x82, 0x0E, 0xB2, 0x18, 0x08, 0xBC, - 0x24, 0x40, 0xFA, 0x17, 0x30, 0xEC, 0x8C, 0xE1, 0x03, 0x6C, 0x19, 0x1D, 0x4D, 0x6A, 0x41, 0x82, - 0xEC, 0x9A, 0x7C, 0x50, 0x5A, 0x7B, 0x8B, 0x06, 0x67, 0xA1, 0x60, 0x2F, 0x6B, 0xA0, 0x5E, 0x11, - 0x20, 0xA4, 0xA0, 0xCB, 0xAB, 0x15, 0x62, 0x68, 0x30, 0x2C, 0x08, 0x0C, 0x14, 0x2E, 0xC0, 0xB6, - 0x89, 0x6A, 0xA7, 0x4D, 0xDD, 0x9A, 0xD2, 0xB6, 0xB2, 0xAB, 0x55, 0xA8, 0xF3, 0x18, 0xB0, 0x8B, - 0x4A, 0xFC, 0x52, 0xE2, 0x90, 0x94, 0xAB, 0x78, 0xAD, 0x38, 0x96, 0xF6, 0xAD, 0x32, 0x63, 0x31, - 0x46, 0xC9, 0xEC, 0x5E, 0x98, 0x61, 0x5B, 0x16, 0xFF, 0xFF, 0xFF, 0x4E, 0xA1, 0x4E, 0x93, 0xCD, - 0x91, 0x23, 0xC9, 0xDB, 0x69, 0xDB, 0xAB, 0x6D, 0x3A, 0xF0, 0x19, 0xD4, 0x40, 0x0C, 0xFF, 0xFF, - 0x4B, 0x45, 0x4E, 0xFC, 0xE0, 0xAB, 0x72, 0x2D, 0x47, 0x00, 0x92, 0xFE, 0xFF, 0xF2, 0x8D, 0x7C, - 0x95, 0x12, 0xE4, 0xEB, 0x08, 0xAA, 0xA5, 0xBE, 0x33, 0xA8, 0x7E, 0xEF, 0x50, 0x44, 0x58, 0x64, - 0x5C, 0x3A, 0x36, 0x7F, 0xA1, 0xD3, 0x9F, 0xB8, 0xB8, 0x4D, 0xB8, 0x83, 0xD5, 0x73, 0xD5, 0x90, - 0xC0, 0x64, 0xA3, 0x33, 0x2C, 0x0C, 0x02, 0x40, 0x03, 0x05, 0x4D, 0x78, 0x0F, 0x31, 0xC2, 0xFC, - 0xCF, 0x65, 0x23, 0xFA, 0x1A, 0x8C, 0x20, 0x2B, 0x30, 0xB0, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x8F, - 0x34, 0x53, 0x34, 0xCB, 0x83, 0x98, 0x7C, 0x40, 0x2F, 0xE5, 0xF9, 0x40, 0x05, 0x82, 0x6C, 0x12, - 0x50, 0xD3, 0x2A, 0x0E, 0x69, 0xED, 0x80, 0xC0, 0x15, 0xE5, 0xD4, 0x74, 0x89, 0xB1, 0x10, 0xD0, - 0x27, 0xA1, 0x18, 0xA4, 0x28, 0x09, 0x31, 0x58, 0x79, 0x62, 0x99, 0x70, 0x46, 0x61, 0xB1, 0xAB, - 0x0F, 0xC8, 0xB9, 0xE3, 0x80, 0x6E, 0xCB, 0x0E, 0x34, 0x44, 0xB5, 0x12, 0x19, 0x00, 0x51, 0xD5, - 0xAC, 0x1A, 0x0A, 0x8C, 0x83, 0x21, 0x16, 0x29, 0x6B, 0x9D, 0x90, 0x05, 0x05, 0x9C, 0x59, 0x44, - 0x8C, 0x65, 0xEC, 0xD5, 0xB8, 0x87, 0x0D, 0x9E, 0x45, 0x58, 0x98, 0xE8, 0x11, 0x3D, 0x5B, 0x9B, - 0x67, 0x6D, 0x71, 0x3C, 0xEF, 0xC7, 0xE2, 0xD5, 0x99, 0x96, 0x58, 0xA5, 0x72, 0xA3, 0x33, 0x44, - 0x7C, 0xAB, 0x51, 0xB0, 0x2D, 0xFF, 0xFF, 0xFF, 0xFE, 0x21, 0xB6, 0x2B, 0x62, 0x35, 0xED, 0x42, - 0xE0, 0xC9, 0x5A, 0xFA, 0x1C, 0x51, 0xCC, 0x08, 0x3C, 0xC3, 0x93, 0x60, 0x0B, 0xFF, 0xF9, 0x43, - 0x01, 0xFC, 0xD9, 0xDF, 0x98, 0x2C, 0x6D, 0xB6, 0x0C, 0xE3, 0x6F, 0xF7, 0x7D, 0x8E, 0x85, 0x5F, - 0x4B, 0x07, 0x9D, 0xFD, 0x75, 0xF3, 0xA8, 0x7B, 0x78, 0x0F, 0x11, 0xB3, 0x79, 0x91, 0x88, 0x49, - 0x6C, 0xEE, 0xDF, 0xF8, 0x57, 0xB1, 0x1D, 0x03, 0xA4, 0x20, 0x5A, 0xCB, 0xAA, 0x5F, 0x62, 0x06, - 0x59, 0x9E, 0x65, 0x26, 0x06, 0x0C, 0x19, 0x5D, 0x14, 0x65, 0xC7, 0xB1, 0x98, 0x94, 0xE1, 0x5E, - 0x89, 0xE7, 0xE7, 0x20, 0x65, 0x19, 0x81, 0xCF, 0xC6, 0xF6, 0x0E, 0x99, 0x40, 0x54, 0x0C, 0x6A, - 0x1D, 0xDD, 0xE6, 0x00, 0x51, 0x9E, 0x2E, 0x0B, 0xDC, 0x02, 0xB4, 0xC8, 0xC7, 0x4D, 0x99, 0xF1, - 0x06, 0x68, 0x02, 0xB5, 0x08, 0xC3, 0xB7, 0x42, 0x24, 0x40, 0xE1, 0x4B, 0xE5, 0xB4, 0x24, 0x12, - 0xC0, 0xD9, 0xD8, 0x14, 0x01, 0x68, 0x91, 0x20, 0xC0, 0xB8, 0x0C, 0x2E, 0x44, 0x34, 0x90, 0x52, - 0x43, 0xCB, 0xD7, 0xDA, 0xE4, 0x7A, 0x14, 0xF2, 0x2A, 0x3D, 0x8A, 0x44, 0x22, 0x0A, 0x57, 0xA6, - 0x1A, 0x15, 0x2B, 0x85, 0x0B, 0x12, 0x81, 0x08, 0x9C, 0xB1, 0x30, 0xEF, 0x69, 0x88, 0xF0, 0xA7, - 0xB7, 0xAB, 0x8F, 0xFE, 0xFB, 0xC7, 0xDD, 0x37, 0x7D, 0xC1, 0x8D, 0x58, 0x5B, 0x84, 0x3F, 0x84, - 0xE9, 0x2A, 0xFA, 0x02, 0x19, 0x57, 0xEE, 0x64, 0xC9, 0xEB, 0xE3, 0x95, 0x5F, 0x1D, 0x18, 0x0B, - 0x02, 0x17, 0xFE, 0x9C, 0xFE, 0x36, 0x45, 0x8A, 0x90, 0x93, 0x45, 0x36, 0xE1, 0x39, 0x29, 0x09, - 0xAD, 0x06, 0xA6, 0x85, 0x73, 0x07, 0xFA, 0x57, 0x6E, 0x2E, 0xBB, 0x0C, 0x62, 0x31, 0x3C, 0x11, - 0xE7, 0x53, 0x49, 0x14, 0xB4, 0x63, 0x7C, 0x8D, 0xE9, 0xFE, 0x3F, 0xC2, 0x1A, 0x31, 0x24, 0x18, - 0x55, 0x23, 0x01, 0xC3, 0x37, 0x45, 0x40, 0xC3, 0xF0, 0x8C, 0x23, 0xA7, 0xC8, 0x35, 0xFD, 0x23, - 0x6F, 0x19, 0x33, 0xFA, 0x83, 0x14, 0x4B, 0x34, 0x70, 0x63, 0x60, 0x87, 0xFF, 0xFB, 0x92, 0x64, - 0x0F, 0x0F, 0x74, 0x68, 0x34, 0xCB, 0x83, 0x79, 0x7B, 0x60, 0x32, 0x45, 0x59, 0x68, 0x24, 0x62, - 0xA4, 0x51, 0x54, 0xD3, 0x36, 0x0D, 0x65, 0xEE, 0xC0, 0xC4, 0x17, 0x67, 0x14, 0x91, 0x8A, 0x58, - 0x31, 0x34, 0x93, 0xAB, 0x79, 0x35, 0xE8, 0x10, 0xF8, 0x58, 0xB8, 0x4D, 0x60, 0xE6, 0x01, 0x03, - 0xA4, 0x9A, 0x15, 0x14, 0x30, 0xE9, 0xA6, 0xEA, 0x7B, 0x25, 0xB3, 0xFF, 0x1F, 0x52, 0x6A, 0xA4, - 0xB5, 0x1A, 0x3B, 0xF0, 0x99, 0xEA, 0x36, 0x90, 0xC9, 0xBC, 0xDC, 0xD5, 0xC9, 0x6F, 0x9B, 0x23, - 0x39, 0x66, 0xD5, 0x9C, 0xC6, 0x06, 0x90, 0x6F, 0x21, 0x6F, 0x90, 0xFA, 0x14, 0xD0, 0x1A, 0x5E, - 0xD5, 0x9A, 0x8A, 0x6F, 0xB1, 0xA1, 0x8F, 0x9F, 0x27, 0x15, 0x95, 0x9A, 0x2A, 0x4E, 0x3B, 0x45, - 0x64, 0xA3, 0xCA, 0x3E, 0x58, 0x9F, 0x73, 0x51, 0xBF, 0xC5, 0x9D, 0x49, 0x10, 0xE0, 0x10, 0x84, - 0xA1, 0x78, 0x67, 0x6C, 0x31, 0x13, 0xB8, 0x8C, 0x75, 0x96, 0xE5, 0x21, 0xF8, 0x68, 0x44, 0x08, - 0x40, 0x00, 0x00, 0x2D, 0x51, 0xFE, 0xFF, 0xF4, 0xA3, 0x2D, 0xE8, 0x50, 0xC8, 0x54, 0x18, 0x5E, - 0x70, 0x34, 0xD6, 0xA1, 0xFF, 0xB9, 0x73, 0xE6, 0x2B, 0xF0, 0x8C, 0xCE, 0x6A, 0xCD, 0x75, 0x8C, - 0xC0, 0xC6, 0x84, 0xAA, 0x5F, 0x4A, 0x7E, 0x87, 0x6E, 0xA8, 0xFC, 0x20, 0x8E, 0x0E, 0x9D, 0xD7, - 0x7F, 0x59, 0xDB, 0x0C, 0x30, 0xDD, 0xCD, 0xBA, 0x20, 0x60, 0x13, 0x24, 0x4C, 0xFC, 0x8F, 0x3D, - 0x65, 0xC0, 0x52, 0x07, 0xA1, 0x82, 0x42, 0x1B, 0x52, 0x86, 0x94, 0x10, 0x12, 0x39, 0xA4, 0xB8, - 0x08, 0x42, 0x2C, 0xD8, 0xE5, 0xAF, 0x25, 0x64, 0xED, 0x24, 0x1D, 0x38, 0xD1, 0x88, 0x00, 0x75, - 0x55, 0xA0, 0x44, 0x42, 0xE4, 0x7B, 0x12, 0x20, 0x1C, 0x02, 0xC4, 0x70, 0xD4, 0xDF, 0x4E, 0x93, - 0x2E, 0x64, 0xC4, 0xEC, 0x86, 0x15, 0x88, 0x78, 0x0C, 0xE2, 0xE6, 0x69, 0x98, 0xE6, 0xEE, 0x5B, - 0x55, 0xE6, 0x99, 0x04, 0x02, 0x51, 0x81, 0xA4, 0x57, 0x22, 0x31, 0x24, 0x4C, 0x43, 0x9D, 0x5E, - 0x21, 0xEA, 0xA6, 0xF5, 0x52, 0xC4, 0x0B, 0x4A, 0xE2, 0x9E, 0x99, 0x7C, 0xD3, 0x8F, 0xB8, 0xAD, - 0x86, 0x82, 0xC2, 0xAE, 0x8C, 0x6C, 0xF2, 0x66, 0x05, 0x0E, 0x85, 0x0A, 0xF9, 0x30, 0x2E, 0x0B, - 0x92, 0xD4, 0x49, 0xDB, 0x65, 0x60, 0x49, 0xAB, 0xDB, 0x59, 0x1F, 0xCC, 0x25, 0xA9, 0xAB, 0x8A, - 0xE5, 0xEE, 0x73, 0x46, 0x46, 0xD0, 0x50, 0x04, 0x30, 0xB3, 0xD0, 0x38, 0x36, 0xA2, 0x07, 0x2F, - 0x2A, 0x00, 0xA1, 0xDE, 0x08, 0xF8, 0xF9, 0x41, 0x0E, 0x4F, 0xFA, 0xBC, 0x89, 0x09, 0x3A, 0x32, - 0x91, 0x89, 0xFD, 0x08, 0xDA, 0xFD, 0xCF, 0x4C, 0xFC, 0x20, 0x6C, 0x10, 0xDC, 0x94, 0xA7, 0x60, - 0xA1, 0x49, 0xCA, 0x13, 0x84, 0x04, 0x3C, 0x49, 0xCC, 0x58, 0x63, 0x4A, 0xD4, 0x9B, 0xD1, 0xDD, - 0x62, 0xBB, 0x8C, 0xB8, 0x84, 0x34, 0x04, 0xBA, 0x39, 0x5C, 0x40, 0x26, 0x44, 0x88, 0xFF, 0xFB, - 0x92, 0x64, 0x10, 0x8F, 0x74, 0x82, 0x34, 0x4E, 0x83, 0x7A, 0xC0, 0xF0, 0x2E, 0xE2, 0xBA, 0x18, - 0x05, 0x26, 0x1A, 0x11, 0x80, 0xD1, 0x3A, 0x0D, 0xE9, 0xE9, 0x80, 0xC1, 0x93, 0xE6, 0xE0, 0x91, - 0x8A, 0x49, 0x9C, 0x99, 0xC3, 0x97, 0xC1, 0xCB, 0x8D, 0x28, 0x23, 0x92, 0x38, 0x31, 0xA9, 0xA3, - 0x02, 0x67, 0x87, 0x81, 0xA5, 0x02, 0xAA, 0x3D, 0x43, 0x8D, 0x87, 0xB8, 0xBA, 0x80, 0xE9, 0x5D, - 0xCF, 0xE4, 0x69, 0xCB, 0x7D, 0x20, 0x38, 0xAA, 0x7B, 0xCB, 0x8B, 0xA2, 0xE3, 0x3B, 0x14, 0xD0, - 0xF6, 0xEA, 0x3C, 0xCA, 0x25, 0x1A, 0x4C, 0xB9, 0x70, 0x58, 0xE9, 0x23, 0x75, 0x8A, 0xB4, 0x35, - 0x34, 0xA8, 0xC7, 0x1B, 0x66, 0xB0, 0xD4, 0x5A, 0xFD, 0x15, 0x7B, 0x1D, 0x8E, 0x3D, 0x54, 0xB2, - 0x97, 0xDA, 0x51, 0x14, 0xE4, 0x91, 0xCB, 0xEC, 0xC4, 0x7A, 0x33, 0x43, 0x5E, 0xE4, 0x46, 0x4F, - 0x83, 0xA8, 0x98, 0x16, 0xE5, 0xB6, 0x94, 0xC1, 0x9B, 0xAB, 0xEE, 0xDD, 0x6C, 0x94, 0xF8, 0xC1, - 0x97, 0xD0, 0xC0, 0x00, 0x00, 0x22, 0xA2, 0xEE, 0xF7, 0x03, 0xD4, 0xFE, 0x07, 0x64, 0x45, 0x91, - 0x8F, 0x05, 0x0C, 0xF0, 0xB1, 0xA0, 0x21, 0x85, 0x01, 0xAF, 0x13, 0xCE, 0xF5, 0xBF, 0xF9, 0x94, - 0x78, 0xA3, 0x4E, 0xA4, 0x60, 0x92, 0x63, 0x20, 0xAD, 0x98, 0xAB, 0x2E, 0x2A, 0x01, 0x40, 0xF6, - 0x66, 0xA6, 0xE6, 0x06, 0x10, 0x6C, 0x93, 0x86, 0x64, 0x1E, 0x18, 0xA2, 0x18, 0xA8, 0x6D, 0xA5, - 0x06, 0x46, 0x18, 0x70, 0x8E, 0x40, 0xC0, 0x60, 0x23, 0xC6, 0x95, 0xA0, 0x55, 0x11, 0x9D, 0x74, - 0x66, 0xC8, 0xA9, 0x90, 0x0C, 0x59, 0xBA, 0x72, 0x62, 0xCB, 0x1A, 0xB2, 0xC0, 0x65, 0x60, 0x05, - 0x6F, 0x70, 0x10, 0xB8, 0xB2, 0x45, 0x6B, 0x2C, 0xDA, 0x16, 0xB4, 0x92, 0xF2, 0x25, 0x62, 0xE2, - 0x40, 0x4B, 0x0D, 0x50, 0x5D, 0x92, 0x80, 0xAB, 0x23, 0x67, 0xF1, 0x38, 0x6B, 0x77, 0x12, 0xB8, - 0x6B, 0x38, 0xD0, 0xB6, 0x22, 0x60, 0xE4, 0x75, 0x17, 0x00, 0x24, 0x00, 0x42, 0x20, 0xC8, 0xC5, - 0x21, 0x2F, 0x46, 0x2F, 0xA0, 0xA3, 0xBE, 0x6F, 0x9B, 0xA6, 0x10, 0xB8, 0xCC, 0xCA, 0xB9, 0xDC, - 0x70, 0x8D, 0x88, 0xCE, 0xFA, 0x68, 0x4B, 0x8D, 0x30, 0x2B, 0x5F, 0xB7, 0x1B, 0x87, 0x08, 0x84, - 0xA9, 0x9E, 0x16, 0x23, 0xD9, 0x03, 0x87, 0xEC, 0xCD, 0x0A, 0x85, 0xEC, 0x21, 0x07, 0xBE, 0x59, - 0x19, 0x9F, 0x48, 0x86, 0x8D, 0x4B, 0x80, 0xC4, 0x30, 0x45, 0xAA, 0xC6, 0x2A, 0xE4, 0x9E, 0x85, - 0x01, 0x18, 0x98, 0x72, 0x55, 0x3E, 0x86, 0xFE, 0xC8, 0x6E, 0xA5, 0x6D, 0x0C, 0xE0, 0x82, 0xF8, - 0x21, 0x7A, 0x60, 0x85, 0x00, 0xCF, 0x8A, 0x10, 0x53, 0xFF, 0xFA, 0x3F, 0x2A, 0x80, 0x00, 0x03, - 0x84, 0x48, 0x01, 0x14, 0x1A, 0x19, 0x96, 0xDE, 0x63, 0x80, 0xC8, 0xD2, 0x60, 0xC7, 0x01, 0x03, - 0x33, 0x8F, 0x8C, 0x2E, 0x0F, 0x32, 0xB9, 0x24, 0xC8, 0x24, 0x78, 0xA3, 0x77, 0x63, 0x25, 0xC3, - 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x87, 0xA4, 0x1B, 0x33, 0x4F, 0x2B, 0x99, 0x7A, 0x72, 0x34, 0xA6, - 0x69, 0x55, 0x1C, 0xC7, 0x4A, 0x52, 0x00, 0xD3, 0x32, 0x0E, 0x69, 0xE9, 0xC0, 0xB2, 0x18, 0x27, - 0x34, 0x70, 0x8A, 0x60, 0xC3, 0xB8, 0x38, 0xB9, 0xC6, 0xFA, 0xA8, 0x0B, 0x4C, 0xE5, 0xEA, 0x18, - 0x9A, 0x75, 0xCF, 0x33, 0x00, 0x61, 0x29, 0x5A, 0x89, 0xE8, 0x1B, 0x02, 0x82, 0x82, 0x6B, 0xCC, - 0xFD, 0x39, 0x5F, 0x76, 0xD5, 0xBE, 0x20, 0x11, 0xB2, 0xB8, 0xEE, 0x44, 0xA7, 0x97, 0x67, 0xFE, - 0x66, 0x4A, 0xA3, 0x9E, 0x53, 0x96, 0xE3, 0x94, 0xC9, 0x1E, 0x4C, 0x88, 0xAD, 0x1E, 0xEA, 0xD6, - 0xC6, 0x06, 0x29, 0xDB, 0x7F, 0x5E, 0x3E, 0x66, 0x56, 0xB9, 0xB6, 0xB9, 0xA6, 0xD4, 0x53, 0x9A, - 0xBB, 0x93, 0x31, 0xF0, 0xBC, 0xCB, 0x3A, 0xF9, 0x39, 0x2F, 0xC9, 0x04, 0xCF, 0x37, 0x1E, 0xDF, - 0xB6, 0xD6, 0x55, 0x94, 0xA2, 0x00, 0x00, 0xCA, 0x82, 0xF1, 0x2E, 0xEB, 0x4A, 0xF3, 0x35, 0xB7, - 0x4B, 0x63, 0x10, 0x04, 0x08, 0x9F, 0x59, 0xDA, 0xBB, 0x32, 0x78, 0xDC, 0xDF, 0xB3, 0x55, 0xFF, - 0xDA, 0x3C, 0x73, 0xF2, 0xE2, 0xE2, 0x84, 0x85, 0xEC, 0x8A, 0x79, 0x11, 0x59, 0x4F, 0x95, 0x00, - 0xEF, 0xC4, 0xE0, 0x1C, 0xE8, 0x4D, 0x87, 0x08, 0x0C, 0x58, 0x31, 0x00, 0x78, 0xC0, 0x4E, 0x10, - 0x5A, 0x68, 0xD2, 0x8D, 0xD3, 0x1F, 0x00, 0x8C, 0x28, 0xD2, 0x35, 0x69, 0x88, 0xC9, 0x00, 0xE3, - 0x65, 0x25, 0x8C, 0x51, 0x13, 0x4A, 0x14, 0xEC, 0x19, 0x31, 0xEB, 0x8F, 0xF2, 0x81, 0xA0, 0x23, - 0x06, 0x50, 0xA8, 0xD6, 0x14, 0x30, 0x00, 0xC6, 0x01, 0x20, 0xF0, 0xA0, 0x51, 0xA2, 0x8C, 0x31, - 0x42, 0x5D, 0x04, 0x1B, 0x8C, 0x3B, 0xAC, 0x18, 0xB6, 0xA9, 0xD2, 0xD7, 0x52, 0x5D, 0x04, 0xB0, - 0x30, 0x8C, 0xD1, 0x79, 0x95, 0xFB, 0xF1, 0x12, 0xD4, 0xCC, 0x31, 0x48, 0x81, 0xF4, 0x5C, 0x88, - 0x40, 0x8E, 0x0F, 0xD2, 0x10, 0xD0, 0xAF, 0x2B, 0x50, 0xA6, 0x56, 0xB8, 0xAC, 0x28, 0x93, 0xB9, - 0x29, 0x0D, 0x6D, 0x58, 0xE7, 0xA4, 0x52, 0x78, 0xBF, 0x3F, 0x4A, 0x32, 0x14, 0xC5, 0x02, 0x1C, - 0x5F, 0x8C, 0x78, 0xD8, 0x82, 0x76, 0xA0, 0x63, 0x55, 0x60, 0xF5, 0x73, 0xC4, 0xC8, 0x73, 0x32, - 0xD3, 0x24, 0xDE, 0x0B, 0x33, 0xB7, 0xAB, 0xB7, 0x7B, 0xA0, 0x08, 0x07, 0x03, 0x90, 0x19, 0xFF, - 0x9F, 0x10, 0x48, 0x13, 0x28, 0xA7, 0x11, 0x1F, 0x26, 0xBF, 0xC0, 0xBC, 0xD9, 0x20, 0x23, 0x1B, - 0x9B, 0x35, 0xFD, 0xFE, 0xD0, 0xE6, 0xFE, 0xBF, 0xB6, 0xFE, 0x26, 0x06, 0x2A, 0xDF, 0xEB, 0x1C, - 0x72, 0xB7, 0xB6, 0x24, 0xDC, 0xAA, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x21, 0xAA, 0x15, 0x98, 0x44, - 0x46, 0x1E, 0x2C, 0x40, 0x0B, 0x10, 0x86, 0x15, 0x80, 0x26, 0x02, 0x86, 0xC6, 0x22, 0x08, 0xE6, - 0x21, 0x0C, 0x66, 0x3C, 0x96, 0xE0, 0x20, 0x9C, 0x40, 0x04, 0x1C, 0xB4, 0x62, 0x86, 0x1B, 0x38, - 0x10, 0xC9, 0xFF, 0xFB, 0x92, 0x64, 0x16, 0x06, 0x04, 0x32, 0x34, 0x4D, 0x3B, 0xBA, 0x4A, 0xF0, - 0x34, 0xE2, 0x09, 0xED, 0x18, 0x4F, 0x1A, 0x90, 0x34, 0xD1, 0x2E, 0x4E, 0xE1, 0x6D, 0x80, 0xC3, - 0x1E, 0xE7, 0xE8, 0xC0, 0x88, 0x0B, 0x83, 0x08, 0x71, 0xC5, 0x82, 0x46, 0x89, 0x19, 0x71, 0x9D, - 0xF5, 0x29, 0x28, 0x2A, 0xA8, 0xD4, 0xB9, 0xE2, 0x51, 0x26, 0x99, 0x18, 0x8D, 0xC2, 0xA7, 0x70, - 0x54, 0x88, 0x96, 0xD9, 0xA0, 0xA5, 0x82, 0x9C, 0xCD, 0xAF, 0xE7, 0xA8, 0x16, 0x57, 0x93, 0xFE, - 0xE4, 0xB1, 0x64, 0x11, 0x3D, 0x18, 0x46, 0xE9, 0x56, 0x0B, 0x1B, 0xBC, 0xB2, 0xBB, 0xA9, 0xCA, - 0x4D, 0x7D, 0x39, 0x3D, 0x16, 0x5A, 0x4E, 0x8D, 0xCF, 0x7F, 0x2A, 0x2D, 0x8A, 0x89, 0x60, 0xA8, - 0x94, 0x5F, 0xD9, 0x86, 0xC2, 0xD9, 0xCA, 0xDF, 0xB4, 0x5F, 0xD4, 0x7E, 0x2D, 0xA6, 0x9B, 0x67, - 0x50, 0x00, 0x02, 0x00, 0xA0, 0x00, 0x01, 0x80, 0x22, 0x9C, 0x01, 0x0F, 0xFF, 0x57, 0x0E, 0xAF, - 0xA3, 0x56, 0x97, 0x79, 0x6D, 0xBD, 0x61, 0x43, 0xC3, 0x80, 0x3F, 0x76, 0xC0, 0x3E, 0xA5, 0x21, - 0xC0, 0xD9, 0x0F, 0xB7, 0xC5, 0x3E, 0xE4, 0x59, 0x2C, 0xC2, 0xD4, 0x3F, 0xF5, 0x83, 0x32, 0x42, - 0x6A, 0x24, 0x62, 0xAE, 0x0F, 0x06, 0x09, 0x84, 0x1C, 0x04, 0x98, 0x6A, 0x80, 0x1F, 0x8F, 0x35, - 0x98, 0x3A, 0x0D, 0x26, 0xA9, 0x8A, 0xC7, 0x71, 0xA1, 0xC2, 0x01, 0x83, 0xE2, 0x81, 0x93, 0x25, - 0x51, 0x84, 0xE0, 0xAC, 0x7C, 0xC0, 0x00, 0x90, 0xC3, 0x71, 0x58, 0xC1, 0xE0, 0x0C, 0x1C, 0x63, - 0xDF, 0x07, 0xC2, 0x4C, 0x95, 0x07, 0x14, 0x28, 0x45, 0xC3, 0x24, 0x20, 0x7A, 0x56, 0xB9, 0x08, - 0x9C, 0xBE, 0x18, 0x2B, 0x64, 0x50, 0xC0, 0xD5, 0xDA, 0xB8, 0x92, 0x4A, 0x10, 0xE5, 0x08, 0xC6, - 0xCF, 0x5A, 0x88, 0x54, 0x2D, 0x2A, 0x7E, 0x9D, 0x93, 0x32, 0xAB, 0x0B, 0x25, 0xB9, 0x4D, 0x80, - 0x01, 0x84, 0x1C, 0xA1, 0x8B, 0x3D, 0xA4, 0xE2, 0x73, 0x39, 0xB4, 0x73, 0x54, 0x58, 0xBE, 0xD8, - 0x36, 0x6D, 0x4B, 0x51, 0x64, 0xD7, 0xE8, 0xA3, 0xCB, 0x51, 0x93, 0x00, 0xB7, 0x46, 0xC7, 0xC7, - 0x69, 0x6B, 0x52, 0x76, 0x8D, 0x7F, 0xA7, 0x15, 0xC0, 0x00, 0x01, 0x45, 0x50, 0x02, 0x52, 0x29, - 0xDE, 0x84, 0x9F, 0x84, 0x70, 0x6E, 0xD3, 0x22, 0x12, 0x49, 0xD5, 0x09, 0x3C, 0xAB, 0x4D, 0x7F, - 0xA3, 0xA1, 0x3F, 0x3B, 0xFF, 0xF3, 0x5F, 0x5D, 0x7F, 0x5F, 0xFF, 0xF3, 0x7F, 0xFF, 0x10, 0xEE, - 0x2C, 0x3D, 0xD1, 0xE4, 0xEE, 0x67, 0xBB, 0x1A, 0x80, 0x00, 0x00, 0xC2, 0x80, 0x17, 0xF4, 0xBE, - 0xC6, 0x0E, 0x9E, 0x67, 0x14, 0x74, 0x02, 0x20, 0xFC, 0xC0, 0x50, 0x50, 0xCA, 0x28, 0x58, 0xC4, - 0x03, 0x00, 0xC1, 0x20, 0xD0, 0xC8, 0xA3, 0x4C, 0xC7, 0xC0, 0xA4, 0xC3, 0xC0, 0x5C, 0xC5, 0xE0, - 0x88, 0x64, 0x02, 0x33, 0x24, 0x6E, 0x30, 0x01, 0x02, 0xD3, 0x04, 0x87, 0x9D, 0x04, 0x22, 0x4B, - 0xD4, 0x0C, 0x12, 0x0C, 0xFF, 0xFB, 0x92, 0x64, 0x1E, 0x04, 0x04, 0x0E, 0x2E, 0x4B, 0x3B, 0xBA, - 0x53, 0x60, 0x34, 0x41, 0x3A, 0x1D, 0x18, 0xA7, 0x00, 0x8F, 0x68, 0xBD, 0x2E, 0x4E, 0xE9, 0x4B, - 0xD0, 0xC4, 0x17, 0xE8, 0xA8, 0x20, 0x89, 0xFB, 0x54, 0x58, 0xD5, 0xA2, 0xEB, 0xA3, 0x6A, 0x55, - 0xC0, 0xA4, 0x41, 0x1D, 0xF8, 0x65, 0x20, 0x57, 0xA6, 0x23, 0x80, 0x50, 0x48, 0xD1, 0x48, 0x42, - 0xCC, 0xCD, 0x41, 0x0C, 0x2A, 0x53, 0x1F, 0x8C, 0xB2, 0xD6, 0x8E, 0xDF, 0x18, 0xE0, 0x60, 0xA0, - 0x88, 0x3E, 0xAA, 0xAC, 0xCE, 0x6D, 0x57, 0x82, 0xF9, 0x31, 0x70, 0x5B, 0x3F, 0xA7, 0x77, 0xFA, - 0x9B, 0x4B, 0x3F, 0xFB, 0x8C, 0x80, 0xBD, 0xF9, 0xEF, 0xFE, 0x7D, 0xF3, 0xC9, 0xA5, 0x08, 0x04, - 0x00, 0x00, 0x00, 0x31, 0xDA, 0x03, 0x02, 0x03, 0x6B, 0x28, 0x5A, 0xD8, 0x50, 0xFD, 0x8B, 0x2D, - 0xCA, 0x1E, 0x77, 0x7E, 0x5A, 0x56, 0x2A, 0xE7, 0x69, 0xF7, 0x44, 0xD5, 0x85, 0x81, 0x5F, 0x79, - 0xED, 0x25, 0xD6, 0x1E, 0x15, 0x28, 0x90, 0xA8, 0xB1, 0x43, 0xD6, 0x8B, 0x07, 0x24, 0x4C, 0xBA, - 0x1B, 0x92, 0x00, 0x18, 0x00, 0xB0, 0x12, 0x5F, 0x63, 0x07, 0x86, 0x63, 0x58, 0x78, 0x13, 0x19, - 0xC1, 0x20, 0x30, 0x04, 0x63, 0x49, 0x70, 0x60, 0xE1, 0x72, 0x10, 0x32, 0x98, 0xDA, 0x44, 0x18, - 0xF4, 0x50, 0x18, 0x6C, 0x27, 0x1C, 0x1E, 0x46, 0x04, 0xF9, 0xE1, 0x5A, 0x6B, 0x11, 0x15, 0x64, - 0x1B, 0x31, 0xA8, 0x42, 0x28, 0x09, 0xA4, 0xB0, 0xB0, 0x49, 0x90, 0x20, 0x45, 0x9E, 0x90, 0xC9, - 0xCE, 0xE1, 0xB4, 0x0C, 0xDF, 0xE1, 0x61, 0x6D, 0x06, 0xF2, 0xEB, 0x6D, 0xE0, 0xA1, 0x01, 0x05, - 0xDA, 0xB9, 0x23, 0x6C, 0x39, 0x94, 0xB2, 0xA5, 0xED, 0x27, 0x6C, 0x8D, 0xC9, 0x9F, 0xAB, 0xF4, - 0xAC, 0x6C, 0x8D, 0x21, 0x7D, 0x4A, 0x01, 0xD1, 0xD6, 0x0D, 0x49, 0x87, 0x84, 0x8B, 0x3C, 0xFF, - 0xFA, 0x10, 0x37, 0xFC, 0x54, 0x10, 0x88, 0x44, 0x24, 0x12, 0x79, 0xFD, 0x5A, 0x5C, 0x04, 0x01, - 0x05, 0x39, 0x6C, 0x00, 0x20, 0x01, 0x9B, 0x9C, 0x6A, 0x6E, 0x2A, 0x46, 0x52, 0x8D, 0xD9, 0xB7, - 0xFD, 0x98, 0xDD, 0x52, 0x82, 0x68, 0xCC, 0x4A, 0x59, 0xA9, 0x72, 0xFD, 0x46, 0xC4, 0x2E, 0xFF, - 0x1D, 0x8C, 0x76, 0xB8, 0x6B, 0xE1, 0x54, 0xC4, 0xD9, 0xF3, 0xB1, 0x5F, 0x6D, 0x7F, 0x2A, 0x00, - 0xED, 0x04, 0xA3, 0x0E, 0x02, 0x13, 0x0B, 0xF0, 0x59, 0x31, 0x46, 0x53, 0x83, 0x79, 0x90, 0x06, - 0xA6, 0x06, 0xE5, 0x2F, 0x19, 0x31, 0x96, 0x6E, 0x71, 0x21, 0xB7, 0x5D, 0x66, 0xC5, 0x60, 0x99, - 0x50, 0x1C, 0x65, 0xB1, 0xA8, 0x89, 0x64, 0x4F, 0x99, 0x34, 0x41, 0xBC, 0xC5, 0x48, 0x63, 0x06, - 0x11, 0x8C, 0xCE, 0x2A, 0x1A, 0x4C, 0x05, 0x05, 0xA6, 0x45, 0x0A, 0x9A, 0x39, 0x82, 0xB1, 0x00, - 0x02, 0x5B, 0x25, 0x67, 0x49, 0xB5, 0x3C, 0x91, 0x80, 0x34, 0x01, 0x6D, 0x35, 0x78, 0xB8, 0x32, - 0x81, 0x81, 0x92, 0x44, 0x04, 0xC2, 0xFF, 0xFB, 0x92, 0x64, 0x2B, 0x8C, 0x04, 0xEF, 0x2F, 0xC9, - 0x93, 0xDC, 0xC8, 0xE0, 0x2D, 0x06, 0xCA, 0x4C, 0x1C, 0x02, 0xD1, 0x94, 0x30, 0xC9, 0x28, 0x2E, - 0xF3, 0x25, 0x50, 0xBD, 0x16, 0xE9, 0x34, 0x60, 0x89, 0xDA, 0x5C, 0x05, 0x00, 0x5F, 0x68, 0xC6, - 0x24, 0x11, 0x70, 0x83, 0x81, 0xB1, 0x0D, 0x80, 0x5F, 0x41, 0xC6, 0xC0, 0x08, 0x29, 0x80, 0xAB, - 0xF1, 0x91, 0xE5, 0xB1, 0x46, 0xA7, 0x82, 0x3D, 0x62, 0xC0, 0x92, 0xC2, 0xDE, 0xE2, 0x90, 0x47, - 0x69, 0xF2, 0xA4, 0xE6, 0xB5, 0xAA, 0xAA, 0xC8, 0x5E, 0x39, 0x36, 0xF0, 0xE7, 0xFF, 0xF3, 0xF2, - 0x2A, 0x28, 0x34, 0xC5, 0x22, 0x08, 0x14, 0x31, 0x12, 0x2C, 0xE4, 0x84, 0x04, 0xA1, 0xBF, 0xF5, - 0xD3, 0x00, 0x00, 0x00, 0x01, 0x00, 0xFE, 0x00, 0x22, 0x2C, 0x6F, 0x56, 0xA0, 0xFB, 0x73, 0xCD, - 0x64, 0xB9, 0xB6, 0xED, 0xA6, 0xB6, 0xFF, 0xF4, 0x5E, 0xA7, 0xBD, 0x6A, 0x64, 0xAF, 0xFA, 0x8A, - 0xB1, 0x1C, 0x0B, 0xEE, 0x71, 0x9E, 0x9C, 0x17, 0x0D, 0xB7, 0xA8, 0xF4, 0xFF, 0xD6, 0x02, 0x3D, - 0xE6, 0x05, 0x00, 0xE6, 0x16, 0x0B, 0x66, 0x7C, 0xB3, 0x87, 0x9E, 0x3A, 0x46, 0x84, 0x1B, 0x86, - 0xE4, 0x99, 0x9F, 0x59, 0xE2, 0x77, 0x32, 0xE9, 0xB7, 0x58, 0x06, 0x99, 0x89, 0x1A, 0x40, 0x36, - 0x00, 0x5F, 0x98, 0xFC, 0x76, 0x63, 0x3D, 0xD1, 0xCE, 0x36, 0x47, 0x82, 0x83, 0x1A, 0x7C, 0x7E, - 0x20, 0x2F, 0x8D, 0x28, 0x80, 0x80, 0x90, 0xB8, 0x21, 0x34, 0x81, 0x4E, 0x8C, 0xCE, 0x5E, 0x33, - 0x39, 0xC2, 0x67, 0xDD, 0xB1, 0x08, 0x40, 0x22, 0xC5, 0x12, 0x08, 0x14, 0xC3, 0x94, 0x05, 0x39, - 0x64, 0x09, 0x0E, 0x34, 0x4D, 0x10, 0x9A, 0x84, 0xEA, 0x73, 0x70, 0x96, 0x24, 0xC4, 0x98, 0xA0, - 0x24, 0xB0, 0xE2, 0xD1, 0x10, 0x00, 0x5B, 0x57, 0x2E, 0x92, 0x28, 0x2C, 0x94, 0x33, 0x55, 0xF1, - 0xA9, 0x15, 0xC7, 0x56, 0x4C, 0xC2, 0x59, 0x6D, 0x6A, 0xAD, 0xC9, 0xBB, 0x3C, 0x95, 0x23, 0x12, - 0xCE, 0x7F, 0xEE, 0x57, 0x2A, 0x59, 0xD7, 0xBF, 0x99, 0xF2, 0x6E, 0xFF, 0xF3, 0xAF, 0x1C, 0xA6, - 0x9C, 0xB7, 0x8E, 0x62, 0xAC, 0xC7, 0xF5, 0xBF, 0x95, 0xCB, 0x1C, 0x2A, 0x6B, 0xF4, 0xFD, 0x8D, - 0x50, 0x00, 0x00, 0x02, 0x02, 0x8E, 0x50, 0x32, 0x2F, 0xBD, 0x3D, 0x7B, 0xB4, 0xF3, 0xEE, 0x03, - 0xAD, 0x0D, 0xF2, 0x07, 0xA2, 0xD2, 0x2A, 0xEB, 0xFF, 0xD6, 0xBC, 0xEB, 0xA1, 0x35, 0x3B, 0xF5, - 0x64, 0x45, 0x9C, 0x13, 0xFE, 0x78, 0x43, 0x9A, 0x27, 0xDB, 0xFD, 0x81, 0x5B, 0xA8, 0x4D, 0x80, - 0x00, 0x00, 0x01, 0x80, 0x22, 0x1A, 0x7C, 0x0C, 0x13, 0xA6, 0x5D, 0xC1, 0xC6, 0xA8, 0x11, 0x26, - 0x3D, 0x09, 0xA6, 0x09, 0x87, 0xC7, 0x3D, 0x49, 0xA7, 0xB5, 0xA2, 0x20, 0x03, 0x3C, 0xC9, 0xF0, - 0x3C, 0xD4, 0x61, 0x34, 0xC4, 0xB0, 0xB8, 0x40, 0x3B, 0x18, 0x6A, 0x70, 0x1C, 0xFE, 0x2E, 0x1A, - 0xC8, 0xC3, 0x98, 0x82, 0x60, 0x19, 0x5E, 0x23, 0xFF, 0xFB, 0x92, 0x64, 0x1C, 0x86, 0x45, 0x4C, - 0x34, 0xCC, 0x3B, 0xBA, 0x7C, 0x40, 0x2D, 0x01, 0x1A, 0x8D, 0x24, 0x62, 0x08, 0x92, 0x34, 0xD5, - 0x3A, 0x0F, 0x6D, 0xEB, 0xC0, 0xC0, 0x17, 0x67, 0xF0, 0x91, 0x89, 0x38, 0x98, 0xC2, 0x02, 0x06, - 0x05, 0x4B, 0x78, 0xCA, 0x72, 0x5A, 0x80, 0xA6, 0x28, 0x05, 0x33, 0xA6, 0x4B, 0x21, 0x21, 0x1D, - 0x12, 0x75, 0xD7, 0x04, 0x4C, 0x0B, 0x91, 0x43, 0x89, 0x84, 0xA8, 0x34, 0xB1, 0x66, 0xAF, 0x05, - 0xCC, 0xE9, 0x8B, 0x01, 0x30, 0xE8, 0xDD, 0x5B, 0xF1, 0xA1, 0x42, 0x25, 0x05, 0xA3, 0xC3, 0x82, - 0x06, 0x56, 0x9E, 0xB2, 0xE9, 0x00, 0x9B, 0xE0, 0xE1, 0xEA, 0xB9, 0xA9, 0xB4, 0x87, 0xAA, 0x58, - 0xD0, 0xC3, 0xCE, 0x8D, 0xC1, 0x1C, 0x07, 0x6D, 0x1E, 0xAA, 0xD3, 0xF8, 0xF2, 0x56, 0x34, 0x32, - 0x4F, 0xF0, 0xA7, 0x78, 0xE7, 0xA3, 0xF2, 0x9A, 0xC9, 0xD0, 0x7D, 0xE4, 0x42, 0x8C, 0x41, 0xA9, - 0x48, 0x37, 0xFE, 0xA6, 0x9C, 0xCD, 0x4B, 0x03, 0x83, 0xFF, 0x6E, 0xB9, 0x0B, 0xB0, 0x00, 0x00, - 0x00, 0x25, 0x35, 0x30, 0x01, 0x99, 0x04, 0x2E, 0xEB, 0x4E, 0xB6, 0xD1, 0x48, 0x01, 0xD2, 0x9B, - 0x4A, 0xBE, 0x0A, 0x3C, 0x9A, 0x1D, 0x45, 0xF2, 0x45, 0x69, 0xB0, 0xF9, 0x45, 0xBD, 0xF7, 0x66, - 0x27, 0x15, 0x45, 0xA7, 0xFF, 0x9D, 0xA4, 0x21, 0x49, 0x69, 0x32, 0xE7, 0x19, 0x01, 0xD3, 0x0A, - 0xE0, 0x8C, 0x08, 0x13, 0x00, 0x70, 0x21, 0x08, 0xC3, 0x60, 0xC0, 0x75, 0x06, 0x8C, 0x4D, 0x41, - 0xC8, 0x1C, 0x0D, 0xA1, 0x00, 0x48, 0x62, 0x4A, 0x0B, 0xA0, 0x22, 0xA3, 0x03, 0x33, 0x1C, 0x63, - 0x3B, 0x72, 0x41, 0xE2, 0xD3, 0x30, 0x39, 0x30, 0x92, 0x73, 0x64, 0x1E, 0x65, 0xAC, 0xB0, 0x46, - 0xA0, 0x4C, 0x62, 0xC9, 0x1F, 0xF0, 0x70, 0xAA, 0x48, 0xDC, 0x55, 0x12, 0xB0, 0xE0, 0xC0, 0x55, - 0x07, 0x61, 0x46, 0x14, 0x9E, 0x9F, 0x71, 0xB4, 0x6F, 0x56, 0xAC, 0x22, 0xC5, 0x80, 0x15, 0x34, - 0x7D, 0xED, 0xA1, 0x82, 0x2D, 0xCE, 0x25, 0xB1, 0x2B, 0x22, 0x99, 0x4A, 0x69, 0x42, 0x80, 0x8D, - 0x0E, 0x8D, 0x6B, 0x33, 0x30, 0x29, 0x92, 0xDA, 0xD8, 0x9F, 0x30, 0x47, 0x76, 0xB9, 0x35, 0xF1, - 0xDB, 0xA0, 0xFE, 0x4F, 0x1C, 0x36, 0xF6, 0x14, 0xDE, 0x57, 0xB3, 0xF4, 0x52, 0xAA, 0xCC, 0x22, - 0x9A, 0xD7, 0x68, 0x1B, 0xFF, 0xB4, 0x6B, 0x30, 0x8B, 0x83, 0xAD, 0xB3, 0x40, 0x00, 0x04, 0x80, - 0x92, 0x93, 0xFE, 0xD2, 0x15, 0x08, 0xC9, 0x3B, 0xC0, 0x23, 0x58, 0x42, 0xC5, 0xB8, 0xA8, 0x0C, - 0x82, 0x0B, 0xD0, 0x1D, 0x17, 0xE5, 0x11, 0x29, 0xC2, 0xE8, 0x40, 0x92, 0x1F, 0x06, 0x1B, 0xFD, - 0xAC, 0xF5, 0xFF, 0x7D, 0x2D, 0x93, 0x39, 0x70, 0x22, 0x3B, 0xCD, 0x2A, 0xD3, 0x5B, 0x30, 0x90, - 0x18, 0xD8, 0xF2, 0x33, 0x46, 0x04, 0xE1, 0x46, 0x02, 0x36, 0x1F, 0xBD, 0x72, 0x6F, 0x00, 0xC1, - 0x8D, 0x43, 0xC6, 0x37, 0x2D, 0x04, 0xA4, 0x4B, 0xE0, 0x61, 0xFF, 0xFB, 0x92, 0x64, 0x0F, 0x0F, - 0x94, 0x73, 0x34, 0xCE, 0x03, 0x9A, 0x7C, 0x40, 0x32, 0x23, 0x69, 0xDB, 0x25, 0x49, 0x44, 0x11, - 0x4C, 0xD1, 0x38, 0x0E, 0xED, 0xEB, 0xC8, 0xC1, 0x17, 0xA7, 0x10, 0xB3, 0x09, 0xD0, 0xA2, 0x20, - 0x09, 0x4A, 0x7A, 0x01, 0xF1, 0x88, 0x00, 0xC6, 0x25, 0x22, 0x10, 0x80, 0x85, 0xB1, 0x89, 0x30, - 0xD2, 0x82, 0xDB, 0x00, 0xD6, 0x19, 0xAC, 0x34, 0x22, 0x74, 0x92, 0x11, 0x67, 0xF4, 0xC0, 0x97, - 0x5B, 0x8C, 0x85, 0x94, 0x19, 0x3B, 0x48, 0x1D, 0x1B, 0x47, 0x92, 0x80, 0xB5, 0xEA, 0x2A, 0xA8, - 0x42, 0x17, 0xFE, 0x0F, 0x19, 0x2C, 0x34, 0x8E, 0xBC, 0x50, 0xC4, 0xB4, 0x07, 0x68, 0x76, 0xE2, - 0x08, 0x6E, 0xDB, 0x3D, 0xA9, 0xDB, 0x02, 0xF0, 0x50, 0x71, 0x60, 0x9F, 0x05, 0xF6, 0x3B, 0xC8, - 0x27, 0x95, 0x31, 0x76, 0x8D, 0x64, 0x5D, 0xD6, 0x76, 0xE4, 0xAF, 0x9B, 0x1B, 0x45, 0x6F, 0xC5, - 0x55, 0xE1, 0x98, 0xA9, 0x45, 0x5D, 0xDF, 0xFE, 0x54, 0x2A, 0x69, 0xA1, 0x0B, 0x7C, 0xC4, 0x00, - 0x05, 0x80, 0x00, 0x82, 0x2F, 0xDF, 0xD7, 0x6F, 0x8C, 0x93, 0x84, 0xE3, 0xF5, 0xAF, 0xE3, 0x6B, - 0xB6, 0x2C, 0x9B, 0x51, 0x35, 0xBE, 0x62, 0x4F, 0xBF, 0xEA, 0xB2, 0x42, 0xB2, 0xA7, 0xFC, 0x13, - 0x9E, 0x4C, 0x0C, 0xBF, 0xA6, 0x63, 0xA5, 0xE7, 0xBE, 0x2E, 0xA7, 0xC3, 0xC8, 0x6C, 0xEB, 0xF9, - 0x46, 0xE2, 0x87, 0x86, 0x00, 0x05, 0xE6, 0x13, 0x28, 0xA6, 0x1E, 0x83, 0xE2, 0x40, 0xC0, 0xE0, - 0x18, 0x6A, 0xE5, 0xAE, 0x64, 0xE8, 0x26, 0x60, 0xF8, 0x14, 0x59, 0xD3, 0x48, 0x44, 0x83, 0x0C, - 0x03, 0x31, 0x3C, 0x20, 0x74, 0xD1, 0xE0, 0xFE, 0x8A, 0x88, 0x15, 0x40, 0x4C, 0x14, 0xC0, 0xC0, - 0x0F, 0x42, 0x01, 0x9A, 0xF8, 0x85, 0x98, 0x31, 0x76, 0xD4, 0xA8, 0xAA, 0x84, 0x06, 0x3B, 0x8E, - 0x40, 0x24, 0x07, 0x3B, 0x81, 0x13, 0x44, 0xC0, 0x46, 0xDD, 0x3A, 0x8E, 0xDC, 0x5E, 0xB5, 0x58, - 0x28, 0x1C, 0x31, 0x6A, 0x2C, 0x23, 0x02, 0x1E, 0x46, 0xA6, 0x7A, 0x60, 0x71, 0xE8, 0x88, 0xC7, - 0x09, 0x43, 0xE1, 0xDA, 0xDB, 0x1F, 0xCA, 0x81, 0x8F, 0xF6, 0x2F, 0xAB, 0x5A, 0xEA, 0x9D, 0xB5, - 0x01, 0xA9, 0x5A, 0x23, 0xE9, 0xAD, 0xD3, 0x9F, 0xEC, 0x3F, 0xC3, 0x72, 0x4E, 0x59, 0x22, 0x20, - 0x09, 0x49, 0xFE, 0x1F, 0x51, 0x3A, 0x86, 0x47, 0x6F, 0x55, 0x2C, 0xE0, 0x02, 0x91, 0x67, 0x98, - 0x99, 0xDA, 0x2F, 0x0D, 0x2E, 0xFF, 0x8F, 0xD0, 0x34, 0x91, 0x45, 0xE6, 0x0B, 0x1D, 0x4C, 0x63, - 0x3F, 0x10, 0x5B, 0x20, 0x63, 0xC1, 0x03, 0xA0, 0x11, 0xA5, 0x2F, 0xEA, 0x64, 0xA1, 0xB4, 0x46, - 0x2D, 0xD9, 0x5D, 0xE5, 0xF6, 0x6D, 0xEC, 0x51, 0x5D, 0x27, 0xC7, 0xD5, 0x80, 0x00, 0x03, 0xBC, - 0x30, 0x00, 0x01, 0x41, 0x43, 0x26, 0x14, 0x50, 0x89, 0x0C, 0x98, 0x3E, 0x30, 0xFC, 0x80, 0x35, - 0x12, 0x9C, 0x32, 0x94, 0x50, 0x31, 0x48, 0x4D, 0x30, 0xA8, 0x23, 0x34, 0xFF, 0xFB, 0x92, 0x64, - 0x10, 0x07, 0x14, 0x88, 0x34, 0x4D, 0xAB, 0xBA, 0x7C, 0xB0, 0x31, 0xA6, 0x69, 0xAB, 0x1C, 0x62, - 0xB0, 0x50, 0xF4, 0xD1, 0x39, 0x0E, 0x65, 0xB2, 0xD0, 0xBE, 0x17, 0xA6, 0x24, 0x53, 0x8D, 0xB9, - 0x71, 0x35, 0x12, 0x16, 0x8C, 0x05, 0x00, 0x42, 0x2D, 0xE3, 0x02, 0x1A, 0x00, 0x50, 0x78, 0x61, - 0xB8, 0x5A, 0xDD, 0xC6, 0x9D, 0xA5, 0xE8, 0xB3, 0x01, 0xA4, 0x21, 0x8F, 0xA1, 0x0A, 0x9B, 0x43, - 0xA1, 0x56, 0x84, 0xEA, 0xA7, 0xAD, 0x91, 0x0C, 0x12, 0x66, 0xBD, 0x1F, 0x72, 0x61, 0x20, 0x62, - 0x6A, 0x95, 0x65, 0x82, 0x80, 0x45, 0x2F, 0xD8, 0x0E, 0x5C, 0xBF, 0x22, 0x2D, 0xD4, 0xC7, 0x8E, - 0x7B, 0x17, 0xD9, 0x7E, 0x49, 0xD2, 0x2A, 0xD9, 0x7A, 0x0C, 0xA5, 0xC7, 0xF8, 0xFE, 0x4A, 0x32, - 0x62, 0x08, 0x68, 0x6B, 0xE7, 0x78, 0xDD, 0x52, 0xBF, 0xC4, 0x77, 0xF9, 0x98, 0x64, 0x6B, 0xB3, - 0x6F, 0xD1, 0xCD, 0x55, 0x09, 0xE8, 0x48, 0xDD, 0x6F, 0xC8, 0xB7, 0xB6, 0xF0, 0xDC, 0x72, 0x6F, - 0x73, 0x28, 0x00, 0x34, 0x00, 0x40, 0x05, 0x88, 0x01, 0x5C, 0xD2, 0x5A, 0x04, 0x4E, 0xBD, 0x71, - 0x48, 0x3B, 0x2D, 0xD4, 0x54, 0x63, 0xFF, 0x43, 0xA2, 0x55, 0x63, 0x61, 0x43, 0x8D, 0xFF, 0xF2, - 0x67, 0x75, 0xD8, 0xF7, 0x4B, 0xA7, 0x0A, 0x6C, 0x3B, 0x42, 0x05, 0x72, 0xA8, 0x10, 0x07, 0x74, - 0x18, 0x16, 0x34, 0x00, 0x23, 0xF3, 0x50, 0x30, 0x48, 0x60, 0x43, 0x20, 0x05, 0x86, 0x8B, 0x8E, - 0x62, 0x63, 0xF1, 0xBC, 0xFF, 0x00, 0x78, 0x21, 0x87, 0x4D, 0x02, 0x03, 0x11, 0x93, 0x74, 0x06, - 0x08, 0x14, 0x18, 0x1C, 0x6A, 0x67, 0x21, 0xC1, 0xA9, 0x30, 0xE6, 0x04, 0x00, 0x98, 0x14, 0x12, - 0x0A, 0x22, 0x99, 0x98, 0xA4, 0x0E, 0x05, 0xB7, 0x60, 0x10, 0x88, 0xD5, 0x60, 0xA5, 0x9F, 0x21, - 0x20, 0x80, 0x34, 0xAB, 0x36, 0x84, 0x64, 0x0B, 0x7D, 0x56, 0xE1, 0x2C, 0x88, 0x1C, 0xA5, 0x8E, - 0x62, 0x3F, 0x2A, 0xCB, 0x6F, 0xF8, 0x18, 0x99, 0x4D, 0xF7, 0xC0, 0xE4, 0x37, 0x16, 0x36, 0x28, - 0x00, 0xCF, 0x2D, 0xB5, 0x85, 0x1D, 0x0C, 0x2E, 0xB7, 0xCE, 0x28, 0x6C, 0x51, 0x80, 0x81, 0x1A, - 0x32, 0x86, 0x22, 0x0F, 0x6E, 0x95, 0x02, 0x48, 0x46, 0x7E, 0xA1, 0x9C, 0x4A, 0x14, 0x78, 0x08, - 0x28, 0x58, 0x6A, 0x51, 0xB8, 0xEC, 0x10, 0x22, 0x81, 0x31, 0xD1, 0xD7, 0x80, 0xC0, 0x00, 0x50, - 0x46, 0xCC, 0xBA, 0xB2, 0x3E, 0xAD, 0x40, 0xA0, 0x24, 0xBD, 0x00, 0x15, 0xBF, 0xCF, 0x19, 0x2A, - 0x5B, 0xAD, 0x04, 0x56, 0xFF, 0xF2, 0xAB, 0xB0, 0xF9, 0x2E, 0x72, 0x42, 0xEA, 0xCF, 0xAD, 0xE4, - 0x58, 0x61, 0xC5, 0xB1, 0x80, 0x80, 0xBB, 0xF0, 0x00, 0x95, 0xC0, 0x00, 0x00, 0x00, 0x50, 0xE2, - 0xFF, 0x98, 0x1C, 0x1B, 0x19, 0x70, 0x97, 0x18, 0xBE, 0x07, 0x06, 0x07, 0xC6, 0x09, 0x02, 0x26, - 0x88, 0xE6, 0xA6, 0x8F, 0x03, 0xE6, 0x0E, 0x05, 0x86, 0x00, 0x89, 0xE6, 0x55, 0xB7, 0xFF, 0xFB, - 0x92, 0x64, 0x12, 0x07, 0xF4, 0x8E, 0x34, 0x4D, 0xC3, 0xBA, 0x7B, 0xD0, 0x2E, 0x66, 0x89, 0x25, - 0x34, 0xA6, 0xD4, 0x12, 0x94, 0xCD, 0x32, 0x0E, 0xF3, 0x47, 0x48, 0xBF, 0x9A, 0x24, 0xC0, 0xF0, - 0x1C, 0xA0, 0xE6, 0x29, 0x00, 0xA0, 0xC1, 0x3C, 0x84, 0x3E, 0x33, 0x05, 0x88, 0x01, 0x08, 0xE5, - 0x00, 0x00, 0x8D, 0x11, 0x8C, 0xCA, 0x18, 0x70, 0x50, 0x20, 0x8E, 0x29, 0xB2, 0x94, 0xFB, 0xCD, - 0x90, 0xCA, 0x54, 0x8F, 0x2C, 0xAC, 0x94, 0xF0, 0x92, 0xA8, 0x16, 0x90, 0x46, 0x82, 0x81, 0x21, - 0xC9, 0x81, 0x8C, 0x97, 0x5C, 0x0D, 0x01, 0x4A, 0x00, 0xA1, 0x2C, 0x4B, 0x98, 0x50, 0x63, 0x66, - 0xF9, 0xFD, 0x40, 0x59, 0xAF, 0x6C, 0xC5, 0xE7, 0x5A, 0x40, 0x70, 0x26, 0x6A, 0xEB, 0xFC, 0x65, - 0x53, 0x68, 0x07, 0x21, 0xF5, 0xEA, 0xC0, 0xD1, 0xFF, 0xFF, 0xFF, 0xEA, 0x79, 0x6F, 0xFF, 0xE4, - 0x52, 0x93, 0x58, 0x4A, 0xC1, 0xDA, 0x49, 0x69, 0xF3, 0x1F, 0x29, 0xE0, 0x17, 0xE2, 0xB6, 0x58, - 0x04, 0x00, 0x12, 0x48, 0xBC, 0x9F, 0xFF, 0xAA, 0xA3, 0x64, 0x93, 0xE3, 0xF0, 0x2D, 0x45, 0x17, - 0xFE, 0xD2, 0x69, 0x2B, 0xF5, 0x01, 0x32, 0x3C, 0xDF, 0xFC, 0x68, 0x15, 0x82, 0x8A, 0x62, 0xE6, - 0x32, 0x08, 0xB7, 0x2E, 0xE8, 0x6F, 0x99, 0xCC, 0xC8, 0xFF, 0xCF, 0x04, 0x36, 0x08, 0x31, 0xE4, - 0xED, 0x30, 0xCC, 0x74, 0x34, 0x5E, 0x08, 0x32, 0xD8, 0x00, 0x1A, 0x05, 0x4C, 0x3F, 0x0B, 0x4E, - 0x50, 0x6B, 0x4F, 0x02, 0x95, 0x32, 0x4A, 0x74, 0x12, 0x91, 0x3F, 0xA4, 0xF8, 0xC1, 0xA0, 0xA0, - 0x22, 0x9C, 0x48, 0xE8, 0x7D, 0x4D, 0x6A, 0xDE, 0x32, 0xF9, 0x11, 0x71, 0x9C, 0x84, 0x00, 0x18, - 0x5B, 0x48, 0xA0, 0x00, 0x64, 0x1E, 0x08, 0x22, 0x04, 0x54, 0x04, 0x5A, 0x12, 0x8B, 0x29, 0xB4, - 0x14, 0x60, 0x3C, 0x7E, 0x01, 0x67, 0xA3, 0xC8, 0xC3, 0x10, 0xBA, 0x6A, 0x2E, 0x5A, 0x98, 0x69, - 0x01, 0xE5, 0xBA, 0x33, 0x05, 0x65, 0x93, 0x6C, 0x00, 0x48, 0xC3, 0xBE, 0x96, 0xC0, 0x40, 0xA0, - 0xB7, 0x0B, 0xA6, 0x2C, 0x38, 0x30, 0x78, 0x3D, 0x9D, 0x61, 0xCF, 0xD2, 0x0D, 0xCF, 0xE5, 0x4C, - 0x84, 0xFA, 0xB9, 0x5C, 0x61, 0xB4, 0x5F, 0xFF, 0xDF, 0xFA, 0xFD, 0xEB, 0x30, 0x62, 0xDD, 0xFF, - 0xFF, 0xD2, 0x95, 0xB4, 0x0C, 0x19, 0x52, 0x56, 0xCA, 0x33, 0xC9, 0x82, 0x59, 0xB0, 0xF1, 0x8A, - 0x04, 0x9F, 0x51, 0xBD, 0x9C, 0xF4, 0x0E, 0x49, 0xBE, 0x50, 0x00, 0x06, 0x3F, 0xA8, 0xDF, 0xCA, - 0x00, 0x41, 0x00, 0x78, 0x58, 0x70, 0x58, 0xF2, 0xA1, 0x83, 0x7F, 0xFD, 0x44, 0x72, 0xE7, 0x9A, - 0x4B, 0xA3, 0x7E, 0x7E, 0x34, 0x3F, 0xEA, 0xF4, 0x71, 0x13, 0x15, 0x89, 0x6E, 0x86, 0x08, 0xE1, - 0xB2, 0x42, 0x4A, 0x9D, 0x79, 0xC1, 0x01, 0xD9, 0x82, 0xA6, 0xE0, 0x74, 0xD2, 0x09, 0x05, 0xCC, - 0x0C, 0x2C, 0x0C, 0x66, 0xC5, 0x0C, 0x01, 0x17, 0x0C, 0x10, 0x0F, 0x0C, 0x1C, 0x11, 0xCD, 0x67, - 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x87, 0x74, 0x6D, 0x33, 0xCD, 0x83, 0xBB, 0x7B, 0xD0, 0x30, 0x06, - 0x69, 0x40, 0x3C, 0x0A, 0x28, 0x11, 0xEC, 0xCD, 0x34, 0xAE, 0x77, 0x4C, 0x40, 0xC3, 0x99, 0xE4, - 0x54, 0xF0, 0x28, 0xA0, 0x1C, 0x43, 0x83, 0x13, 0x05, 0x02, 0x53, 0x13, 0x40, 0x13, 0x96, 0xC8, - 0x63, 0x0E, 0xC0, 0x33, 0x11, 0x00, 0x73, 0x06, 0x3D, 0x18, 0x30, 0x63, 0xAD, 0x70, 0x60, 0xB8, - 0x3C, 0xA5, 0x70, 0xC4, 0x87, 0x13, 0x99, 0x8D, 0xF9, 0x81, 0x08, 0x73, 0xED, 0x6A, 0x64, 0xC4, - 0x09, 0x5F, 0xF7, 0xAD, 0x73, 0x83, 0x82, 0xA0, 0x58, 0x61, 0x86, 0x07, 0x2F, 0x40, 0xF2, 0xE4, - 0xDE, 0x4D, 0xD9, 0x7B, 0xA4, 0x60, 0x04, 0x44, 0xD4, 0x13, 0xB2, 0xE2, 0xA8, 0x22, 0xB5, 0x57, - 0xC9, 0xFE, 0x49, 0x03, 0x96, 0x6A, 0x29, 0x0E, 0x5E, 0x11, 0x8D, 0x8F, 0xFF, 0xEB, 0xFB, 0xDD, - 0x0D, 0xE5, 0xAF, 0xFF, 0xF0, 0x88, 0x42, 0xFB, 0x00, 0xF7, 0x09, 0x13, 0x85, 0x5B, 0x97, 0x32, - 0x77, 0x02, 0xF0, 0xD1, 0x3E, 0x2C, 0x4C, 0x03, 0x46, 0x27, 0xE0, 0x36, 0x4B, 0xFD, 0x45, 0x3A, - 0x18, 0x46, 0x0A, 0x02, 0x78, 0x94, 0x59, 0xC2, 0x2E, 0x15, 0x8E, 0xFF, 0xF5, 0x62, 0xEA, 0x31, - 0x1A, 0x1D, 0x42, 0x66, 0xF9, 0x54, 0xC5, 0x62, 0x6F, 0xA9, 0x98, 0xC4, 0x4D, 0xC6, 0x22, 0xC3, - 0x14, 0x25, 0x0A, 0x71, 0x84, 0x09, 0x9A, 0x98, 0x46, 0x02, 0x27, 0x9A, 0x17, 0xE2, 0x6E, 0x60, - 0xA8, 0xA0, 0x68, 0xC1, 0x43, 0x73, 0xF0, 0xE7, 0x4E, 0x64, 0x24, 0x30, 0x70, 0x40, 0x94, 0x64, - 0x79, 0xA5, 0x39, 0x12, 0x08, 0x78, 0x6E, 0x63, 0x20, 0x99, 0xD3, 0x07, 0x41, 0x84, 0x81, 0x39, - 0x83, 0x60, 0x31, 0x83, 0x80, 0x28, 0x92, 0x98, 0x44, 0x10, 0xA1, 0xD0, 0xC1, 0x76, 0x17, 0xD3, - 0x19, 0x74, 0x04, 0x72, 0x07, 0x97, 0xDB, 0x9D, 0x2E, 0xBA, 0xCD, 0x8A, 0x29, 0xD1, 0x02, 0xC7, - 0x2B, 0x68, 0x62, 0x2C, 0xD5, 0xA6, 0xCB, 0x12, 0xFD, 0x39, 0x1D, 0x99, 0x72, 0xB2, 0x02, 0x9F, - 0x54, 0x69, 0x01, 0x57, 0x02, 0xE8, 0x70, 0xD3, 0x2E, 0x50, 0xBB, 0x3F, 0x96, 0x7D, 0xF6, 0x4F, - 0xCD, 0xC9, 0x19, 0x1D, 0x1F, 0x2A, 0xCA, 0xB7, 0xFF, 0xFF, 0xED, 0x96, 0xA7, 0x78, 0xE9, 0xDA, - 0xE7, 0xFF, 0xFE, 0xD4, 0x1D, 0xE4, 0x86, 0xDB, 0xAA, 0x5C, 0xD9, 0xE4, 0x5D, 0x46, 0x6E, 0x56, - 0x55, 0x04, 0xC1, 0xA2, 0x23, 0x35, 0x12, 0x20, 0x8A, 0xC6, 0xB1, 0x78, 0x16, 0x97, 0xFE, 0xC2, - 0xD6, 0x44, 0x00, 0xB1, 0x12, 0x2E, 0x16, 0x84, 0x31, 0x28, 0x8E, 0x1F, 0x3D, 0x02, 0xB8, 0xA9, - 0xFF, 0xF3, 0x52, 0xC7, 0x1B, 0x9B, 0xFA, 0x9F, 0x52, 0x1F, 0xD4, 0xDA, 0x3A, 0x3C, 0xD1, 0x12, - 0xCA, 0x78, 0x5E, 0x8B, 0x2D, 0x80, 0x00, 0x02, 0xE5, 0x4A, 0x62, 0x51, 0x0C, 0xC5, 0xA5, 0x94, - 0xC7, 0x11, 0x14, 0x00, 0x0B, 0x18, 0x32, 0x03, 0x9A, 0xBD, 0x37, 0x98, 0xFE, 0x3A, 0x82, 0x43, - 0x93, 0x04, 0xFF, 0xFB, 0x92, 0x64, 0x0E, 0x8F, 0xF4, 0x4F, 0x33, 0x4D, 0xAB, 0xBA, 0x7B, 0xD4, - 0x2F, 0x06, 0x68, 0xB0, 0x24, 0x11, 0x28, 0x11, 0x80, 0xCD, 0x34, 0x0E, 0xF3, 0x46, 0xC0, 0xC3, - 0x19, 0xA2, 0xC0, 0x06, 0xA6, 0x70, 0x41, 0xD3, 0x4F, 0x4A, 0x60, 0x10, 0x8C, 0x60, 0x60, 0xD6, - 0x61, 0x28, 0xB0, 0x69, 0xEB, 0x9E, 0x61, 0x28, 0x02, 0x85, 0x83, 0x0C, 0x8D, 0x70, 0xD3, 0x0A, - 0x10, 0xBE, 0x44, 0x1F, 0x0D, 0x20, 0x78, 0x44, 0xE2, 0x99, 0x14, 0x53, 0xEC, 0xBC, 0xBC, 0xAC, - 0x1E, 0x73, 0x33, 0x16, 0x0D, 0xBD, 0xC5, 0xFB, 0x97, 0x52, 0x4D, 0xA8, 0x00, 0xD1, 0x57, 0x32, - 0xDC, 0x00, 0x3C, 0xCA, 0x11, 0x4C, 0x4A, 0xD0, 0x8C, 0xA2, 0xBB, 0xCD, 0xA3, 0xC0, 0xDA, 0xDC, - 0x46, 0x9B, 0x60, 0x9A, 0x62, 0x92, 0x8F, 0xAF, 0xF4, 0x80, 0xD7, 0xFF, 0xF2, 0x37, 0x17, 0x17, - 0x2A, 0x56, 0x7F, 0xFF, 0x0D, 0x6D, 0x0C, 0x51, 0x1F, 0x21, 0xAE, 0xF4, 0x91, 0x0B, 0x38, 0x1C, - 0xEE, 0x34, 0x33, 0xF0, 0x44, 0x7D, 0x0D, 0x68, 0x99, 0x1F, 0xFA, 0xDD, 0x4C, 0xB4, 0x05, 0x0E, - 0x01, 0xA8, 0x87, 0x06, 0x44, 0x19, 0x05, 0xA9, 0x6A, 0x38, 0x4E, 0x19, 0x13, 0x20, 0x8E, 0xAF, - 0xFF, 0xCC, 0x09, 0xC3, 0x76, 0xFE, 0x9F, 0x25, 0x43, 0x15, 0xBF, 0xFF, 0xFD, 0x27, 0x91, 0x81, - 0xB0, 0xA7, 0x28, 0x99, 0x0B, 0x02, 0x46, 0x63, 0x24, 0xA6, 0xA0, 0x82, 0x45, 0x50, 0x34, 0x0A, - 0x41, 0x19, 0x5D, 0xE0, 0x1A, 0x0C, 0x80, 0x65, 0x70, 0x01, 0x89, 0x08, 0x27, 0x3C, 0x90, 0x99, - 0x34, 0x3A, 0x1C, 0x0E, 0x31, 0x73, 0x2C, 0xF7, 0x3E, 0x03, 0x10, 0x8A, 0x4C, 0x3E, 0x15, 0x04, - 0xA4, 0x05, 0xA7, 0x03, 0x18, 0x49, 0x91, 0xCD, 0xC6, 0x3C, 0x7B, 0xBF, 0x6D, 0x39, 0xC9, 0xAF, - 0xD1, 0xCA, 0x1A, 0x20, 0xD0, 0xEC, 0x21, 0xB3, 0x28, 0x41, 0xCB, 0x94, 0xA1, 0xDC, 0x28, 0x01, - 0xA8, 0x68, 0x74, 0x30, 0x29, 0x9C, 0x22, 0xCB, 0x3B, 0x4C, 0xBC, 0x2C, 0x05, 0x9C, 0x04, 0xC0, - 0x7E, 0x28, 0xE5, 0xBC, 0xDE, 0x98, 0xC4, 0x5B, 0xEE, 0x2B, 0xF7, 0xFF, 0xF1, 0x5A, 0xB7, 0xBB, - 0x5A, 0x4B, 0x87, 0xF3, 0xFF, 0xD6, 0xCE, 0xB9, 0x9B, 0x48, 0x9D, 0xFF, 0xD7, 0x33, 0xDC, 0x66, - 0x96, 0xB5, 0x33, 0x32, 0x9F, 0xD3, 0x61, 0x52, 0xA8, 0xA7, 0x6C, 0x93, 0x01, 0xAB, 0xAC, 0x7D, - 0x0B, 0x9E, 0xA1, 0x35, 0x01, 0xD2, 0x39, 0x80, 0x09, 0x61, 0x4B, 0xDC, 0x66, 0x07, 0x2A, 0x65, - 0xE0, 0xC4, 0x37, 0x37, 0xFE, 0x81, 0x50, 0x9A, 0x03, 0x9D, 0x5F, 0x93, 0xC6, 0x11, 0xF1, 0x66, - 0x12, 0x23, 0xC5, 0x60, 0xB5, 0x89, 0xC1, 0x82, 0xCD, 0x3F, 0xFD, 0x5A, 0x58, 0x34, 0xD2, 0xC0, - 0x00, 0x00, 0x00, 0x58, 0x65, 0x2D, 0x15, 0x06, 0x0C, 0x3F, 0x4C, 0x8C, 0xD3, 0x04, 0x96, 0x59, - 0x81, 0x40, 0xE1, 0x35, 0x9E, 0x65, 0xA0, 0x40, 0x62, 0xA0, 0xD4, 0x30, 0x23, 0x19, 0x1A, 0xB2, - 0x18, 0x3C, 0x0B, 0x00, 0xFF, 0xFB, 0x92, 0x64, 0x12, 0x87, 0xF4, 0x3A, 0x33, 0x4E, 0x43, 0xBA, - 0x7B, 0xD0, 0x3E, 0x85, 0x58, 0x70, 0x02, 0x4F, 0x8A, 0x11, 0x38, 0xCD, 0x36, 0xAE, 0xE9, 0xEF, - 0x40, 0xC4, 0x95, 0x22, 0xC0, 0x26, 0xAE, 0x60, 0x42, 0x93, 0x02, 0x48, 0x43, 0xBA, 0x82, 0x73, - 0x12, 0x81, 0xE2, 0x20, 0x64, 0x14, 0xDC, 0x84, 0xB0, 0x28, 0x13, 0x4C, 0x31, 0x61, 0x8E, 0x68, - 0x15, 0x0E, 0x9D, 0x5B, 0x62, 0x46, 0xB5, 0x48, 0xDC, 0xD6, 0xF5, 0x78, 0x01, 0x0E, 0xCA, 0xE2, - 0x00, 0x78, 0x4C, 0x18, 0x7B, 0x3B, 0x76, 0x90, 0x09, 0x21, 0xB0, 0xC6, 0xD0, 0x32, 0x1E, 0x61, - 0xE2, 0x07, 0x01, 0xDC, 0x5B, 0x86, 0x7A, 0xFD, 0xE8, 0xDE, 0xDF, 0x80, 0x24, 0xA8, 0xEA, 0x3C, - 0xAF, 0xF8, 0x55, 0x7F, 0x79, 0x7F, 0x82, 0xF2, 0xBD, 0x8B, 0x19, 0xBB, 0x53, 0x46, 0xFF, 0xFF, - 0x97, 0x48, 0x1D, 0x52, 0x0C, 0xDB, 0x59, 0xA8, 0x7A, 0x59, 0xBA, 0x0C, 0x51, 0x0F, 0x9C, 0x3F, - 0x40, 0x54, 0x91, 0x53, 0x97, 0x58, 0x7D, 0x85, 0xC2, 0x8C, 0x14, 0x35, 0x08, 0x80, 0x80, 0x6A, - 0x11, 0x98, 0x36, 0x0E, 0x16, 0xF7, 0xFF, 0xC4, 0xB0, 0x1B, 0x98, 0x04, 0x68, 0x10, 0x00, 0x86, - 0x3F, 0xFF, 0x00, 0xAB, 0x0B, 0x59, 0xE5, 0x5C, 0x18, 0x22, 0x76, 0x87, 0xB6, 0x80, 0x09, 0x26, - 0xA3, 0x9C, 0x18, 0xF3, 0x3B, 0xFF, 0xFF, 0xFE, 0x52, 0x07, 0x59, 0x82, 0x98, 0x02, 0x1A, 0x19, - 0x0C, 0xE8, 0x18, 0x02, 0x00, 0x02, 0x00, 0x03, 0x07, 0x47, 0xD3, 0x16, 0x31, 0xD3, 0x0D, 0xC4, - 0xD3, 0x12, 0xC4, 0xD1, 0x10, 0x9E, 0x63, 0x3B, 0x86, 0x08, 0x02, 0x48, 0x02, 0x73, 0x15, 0x1E, - 0xE3, 0x79, 0x52, 0x73, 0x05, 0xC2, 0x83, 0x03, 0xC2, 0xF0, 0xCD, 0xE6, 0x48, 0x2A, 0x85, 0x98, - 0x30, 0x40, 0xC3, 0xA7, 0x0C, 0xA2, 0x0B, 0xB8, 0xA3, 0x80, 0x56, 0x7D, 0x87, 0xA8, 0x0C, 0x24, - 0x88, 0x1F, 0x26, 0x05, 0x4E, 0x93, 0x05, 0xA4, 0x97, 0x18, 0xC0, 0xD3, 0xD9, 0xD2, 0x94, 0x07, - 0x6F, 0x2C, 0x33, 0xD6, 0x75, 0x59, 0x7E, 0x85, 0xD5, 0x1C, 0xF3, 0x32, 0xC9, 0x35, 0x05, 0xBB, - 0x4A, 0xE7, 0x7E, 0xD4, 0x12, 0xF4, 0x7F, 0x60, 0xBF, 0xF9, 0xAF, 0xC4, 0x08, 0x5F, 0xC6, 0x52, - 0xFC, 0xC8, 0xD7, 0xA7, 0x8B, 0xCE, 0xBF, 0xFF, 0x14, 0x30, 0x98, 0x72, 0x8E, 0x3F, 0x10, 0x55, - 0xEC, 0x2A, 0x9F, 0xF4, 0x03, 0x03, 0x17, 0xFF, 0xF5, 0xAC, 0x2F, 0x23, 0x28, 0xD9, 0x7E, 0xB4, - 0x51, 0xEC, 0x99, 0x0D, 0x01, 0xDA, 0x07, 0x82, 0x9F, 0xFF, 0x19, 0x84, 0xC0, 0x06, 0x48, 0x44, - 0x8E, 0x8F, 0xE2, 0xB1, 0x44, 0x08, 0xC6, 0x1F, 0x42, 0x51, 0x91, 0x88, 0x5D, 0x60, 0xA4, 0x02, - 0x3A, 0xDE, 0x81, 0x3D, 0x78, 0x96, 0x0C, 0x44, 0x12, 0x1A, 0x33, 0x09, 0x1A, 0x94, 0x34, 0x18, - 0x0A, 0x0A, 0x98, 0x28, 0x01, 0x1D, 0x2D, 0x53, 0x1D, 0x5C, 0x14, 0x62, 0x43, 0x59, 0x89, 0x88, - 0xE7, 0x98, 0xCF, 0x19, 0x1C, 0x0C, 0xFF, 0xFB, 0x92, 0x64, 0x11, 0x0F, 0x04, 0x90, 0x33, 0xCC, - 0x83, 0xBC, 0xC1, 0xD2, 0x2F, 0x66, 0x28, 0xD0, 0x28, 0x0A, 0x56, 0x12, 0xB4, 0xD3, 0x2E, 0x0E, - 0xEF, 0x2B, 0x00, 0xC9, 0x18, 0x64, 0xE8, 0x06, 0x9C, 0x90, 0x16, 0x03, 0x0B, 0x36, 0x8D, 0xC7, - 0x50, 0x32, 0xF8, 0x0C, 0xC3, 0xA1, 0x33, 0x1A, 0x99, 0x86, 0x80, 0x46, 0x08, 0x03, 0x81, 0x00, - 0x66, 0x28, 0x05, 0x81, 0x90, 0x05, 0xD9, 0x52, 0xA0, 0x60, 0x19, 0x44, 0xEA, 0x4B, 0x18, 0x02, - 0x2E, 0x26, 0xCD, 0x0F, 0x85, 0xD6, 0xE2, 0xE9, 0x5C, 0x03, 0xD4, 0xD0, 0x37, 0x32, 0x0A, 0x2B, - 0x56, 0x9C, 0x74, 0x47, 0xB1, 0x8B, 0x4E, 0x48, 0x73, 0x1C, 0x14, 0xBE, 0x82, 0xE4, 0xB3, 0x3C, - 0xDF, 0x98, 0x3F, 0x51, 0xE1, 0x83, 0xAA, 0xEA, 0x19, 0xBF, 0xFF, 0xB9, 0x6B, 0xF3, 0xC6, 0x5B, - 0xFF, 0xF2, 0xEB, 0xFB, 0xA5, 0x97, 0x6A, 0xD4, 0x19, 0x6F, 0xFF, 0xE8, 0x79, 0xA7, 0xDE, 0x82, - 0xBB, 0xE8, 0x87, 0x6B, 0xDB, 0xBE, 0xC5, 0x2F, 0xD3, 0x8B, 0xFE, 0x46, 0x70, 0x48, 0x10, 0xA3, - 0x6C, 0x1C, 0x2F, 0xFF, 0xF2, 0xA0, 0x28, 0xF0, 0xB9, 0x6F, 0xFE, 0x44, 0x12, 0x46, 0xAE, 0xDA, - 0x14, 0x2D, 0x24, 0x09, 0xA1, 0xCC, 0x60, 0x04, 0x88, 0x23, 0x8C, 0x8B, 0x0C, 0x45, 0x9F, 0x9E, - 0x3C, 0x60, 0x98, 0x68, 0x22, 0x06, 0x83, 0x4A, 0x3D, 0x08, 0xFA, 0x34, 0x09, 0x18, 0x34, 0x23, - 0x98, 0xCE, 0xCA, 0x9C, 0x04, 0x3D, 0x8B, 0x08, 0xC6, 0x1B, 0x19, 0x47, 0x90, 0xDE, 0xC6, 0xAD, - 0x10, 0x46, 0x00, 0x8A, 0x46, 0x00, 0x83, 0x47, 0x29, 0xBA, 0x66, 0xF8, 0x34, 0x2A, 0x7A, 0x73, - 0xC6, 0x87, 0x51, 0x66, 0x3A, 0x00, 0x63, 0xEB, 0x00, 0xD2, 0x21, 0xED, 0xC7, 0x3E, 0x10, 0xDD, - 0x81, 0xE1, 0x89, 0xCC, 0x15, 0x11, 0x25, 0x0A, 0x1E, 0x00, 0x93, 0x20, 0x88, 0x75, 0x51, 0x2C, - 0x9F, 0x76, 0xAA, 0x0C, 0x31, 0x11, 0x1B, 0x23, 0xB6, 0x1D, 0xCA, 0x50, 0x57, 0x97, 0x89, 0x05, - 0x4B, 0x3C, 0xE8, 0x32, 0x39, 0x5B, 0xC8, 0x04, 0x94, 0x35, 0x97, 0x5D, 0x09, 0x43, 0x23, 0xA2, - 0x45, 0x25, 0xE1, 0x90, 0x21, 0x57, 0xB2, 0x19, 0x31, 0xA7, 0x63, 0x07, 0x65, 0xFE, 0xD1, 0x2B, - 0xE7, 0xBA, 0xCD, 0xB7, 0x7F, 0x52, 0x1E, 0xD7, 0x9E, 0x7C, 0xB2, 0xEE, 0x54, 0xDD, 0xFF, 0x7C, - 0x6C, 0xFA, 0xF9, 0xA5, 0xD5, 0x2C, 0x4D, 0xF2, 0xCA, 0x58, 0xFD, 0xF2, 0x26, 0x9D, 0x1C, 0x01, - 0x0C, 0x42, 0x00, 0xC0, 0x40, 0x0B, 0xCF, 0x84, 0x3A, 0x4D, 0xFE, 0xC7, 0xF8, 0xE1, 0x13, 0x3A, - 0x69, 0x50, 0x7E, 0x4D, 0x0C, 0x8E, 0xCC, 0x65, 0x7A, 0x31, 0xFA, 0x9C, 0xD3, 0x11, 0x7E, 0x17, - 0x33, 0x2A, 0x2D, 0xCA, 0x0E, 0xB2, 0x8E, 0x87, 0xFF, 0x2A, 0x6C, 0x74, 0x46, 0x63, 0x00, 0x8B, - 0xA5, 0x15, 0x49, 0xD4, 0x42, 0x11, 0x82, 0x99, 0x82, 0xA9, 0x70, 0x83, 0x00, 0x2C, 0xC0, 0x10, - 0x09, 0x0C, 0x03, 0x01, 0x04, 0xC2, 0xB9, 0x0B, 0xFF, 0xFB, 0x92, 0x64, 0x0B, 0x0E, 0x54, 0x4F, - 0x34, 0xCC, 0x83, 0xDA, 0x6A, 0xF0, 0x35, 0x46, 0x49, 0x31, 0x29, 0x63, 0xB4, 0x11, 0x24, 0xD3, - 0x30, 0x4E, 0xE9, 0xEB, 0x80, 0xCB, 0x14, 0x65, 0x54, 0x75, 0x8A, 0x28, 0x4C, 0x06, 0x01, 0x44, - 0xC0, 0x80, 0x01, 0x8C, 0x06, 0x42, 0x04, 0xC6, 0xC0, 0x4D, 0x81, 0xE0, 0x0C, 0x11, 0x93, 0xA9, - 0x54, 0xFD, 0x81, 0x03, 0x1A, 0x32, 0x28, 0x48, 0x42, 0x98, 0x92, 0xE1, 0x70, 0x92, 0xF1, 0xC1, - 0x83, 0x6C, 0x61, 0xC5, 0x00, 0x10, 0x84, 0x6C, 0x2D, 0xDE, 0x1C, 0x30, 0xE1, 0x06, 0x8A, 0xB2, - 0xF8, 0x50, 0x24, 0xFA, 0xC5, 0x72, 0x52, 0x8C, 0x0D, 0x7E, 0x02, 0x81, 0x0B, 0xF8, 0xA8, 0x71, - 0xBF, 0x06, 0x2B, 0xF6, 0xA7, 0x7C, 0x42, 0x04, 0x78, 0xC6, 0x4E, 0x63, 0x5B, 0x4F, 0x11, 0xA5, - 0x34, 0x8D, 0x6C, 0x04, 0x28, 0xF7, 0x51, 0xFE, 0x3B, 0x89, 0xA9, 0x56, 0x86, 0xA3, 0x77, 0x58, - 0xE0, 0x1E, 0x0F, 0xF9, 0x74, 0xF4, 0xE1, 0xFC, 0xBC, 0x6B, 0x24, 0x87, 0xC6, 0x24, 0x58, 0xA1, - 0x00, 0x15, 0x0B, 0xF2, 0x7F, 0x35, 0x82, 0xA8, 0x11, 0x2F, 0xFC, 0x4B, 0x1D, 0xE8, 0x83, 0xC3, - 0xD5, 0xEB, 0xD4, 0x00, 0xC0, 0x28, 0x37, 0x8E, 0xE9, 0xF6, 0x9B, 0xF2, 0x5B, 0xA8, 0x64, 0xCD, - 0x53, 0xE7, 0xFE, 0xCA, 0x0E, 0x5F, 0xFD, 0x22, 0xE9, 0x7C, 0x84, 0x8B, 0x3F, 0xFF, 0xB3, 0xA0, - 0x2B, 0x05, 0x40, 0x40, 0x15, 0x48, 0x0D, 0x85, 0x15, 0x4C, 0x31, 0x23, 0xCC, 0xCE, 0x7E, 0x4D, - 0x81, 0x11, 0x48, 0x86, 0x53, 0x22, 0xC3, 0xF3, 0x65, 0xA5, 0x00, 0x76, 0xBE, 0x62, 0x79, 0x32, - 0x61, 0xC0, 0xCE, 0x65, 0xB9, 0xB6, 0x01, 0x3E, 0x6C, 0x8C, 0x1D, 0x8C, 0x47, 0x82, 0x61, 0x00, - 0x83, 0x82, 0x34, 0x18, 0x8C, 0xF5, 0x96, 0x5D, 0x6B, 0x94, 0xBE, 0xC7, 0x0D, 0x9A, 0x71, 0x3B, - 0xCC, 0xC8, 0x1C, 0xC1, 0x1F, 0xA8, 0x42, 0xC6, 0xC2, 0x34, 0x48, 0x1A, 0x18, 0x28, 0x40, 0x70, - 0xB8, 0xE1, 0x08, 0xB3, 0x30, 0x9C, 0xDA, 0x9B, 0x52, 0xC4, 0xEB, 0x5C, 0x74, 0x9C, 0x7C, 0x5F, - 0xCE, 0x26, 0xB2, 0x5A, 0x03, 0xBB, 0xC5, 0x52, 0x2C, 0x01, 0x6A, 0x7D, 0x1E, 0xE5, 0x6D, 0xE0, - 0xA8, 0x3F, 0x21, 0xCB, 0xFF, 0xDA, 0x95, 0x63, 0xDF, 0x19, 0xDE, 0x71, 0xBC, 0x3E, 0xAE, 0xFF, - 0xFF, 0xF9, 0x35, 0xEB, 0x02, 0x06, 0x9C, 0x1C, 0x2D, 0x29, 0x9C, 0xB3, 0xB8, 0x31, 0x54, 0x00, - 0x3F, 0x09, 0x01, 0xBE, 0xAC, 0x69, 0xBF, 0xF5, 0x14, 0x19, 0xC9, 0xF6, 0x1A, 0x16, 0x93, 0xAC, - 0xAD, 0x7F, 0xFD, 0x40, 0x75, 0x64, 0xC3, 0x65, 0xFC, 0xB5, 0x12, 0x59, 0xA1, 0xB5, 0x28, 0x23, - 0xD6, 0xF7, 0x1A, 0xF9, 0x06, 0x4A, 0x7C, 0x33, 0xE8, 0xFF, 0xF7, 0x0B, 0xA7, 0x43, 0x2A, 0x3E, - 0x18, 0x04, 0x12, 0xF8, 0x1C, 0x06, 0xAD, 0x03, 0x39, 0x8B, 0x00, 0x17, 0x34, 0x20, 0x0D, 0x4C, - 0x2E, 0x1F, 0x0D, 0x71, 0xA4, 0x0C, 0xD5, 0x0C, 0xCC, 0x3C, 0xFF, 0xFB, 0x92, 0x64, 0x0C, 0x86, - 0xD4, 0x4B, 0x33, 0xCC, 0x0B, 0xBA, 0x5B, 0x70, 0x31, 0xC6, 0x79, 0x10, 0x15, 0x62, 0x8A, 0x10, - 0xE8, 0xCD, 0x32, 0xAE, 0xEB, 0x26, 0xC0, 0xC2, 0x98, 0x64, 0x04, 0xF0, 0x1C, 0x32, 0x0C, 0x93, - 0x68, 0xC9, 0x43, 0x84, 0x42, 0x00, 0x18, 0x26, 0x0B, 0x19, 0xCE, 0x46, 0x80, 0x17, 0x97, 0x8D, - 0x14, 0xD2, 0x34, 0xEC, 0x00, 0x2E, 0xA8, 0x88, 0x90, 0x59, 0xD8, 0x0C, 0xD9, 0x12, 0x38, 0x84, - 0x70, 0x74, 0x01, 0x10, 0x18, 0xDD, 0x20, 0xC1, 0xF5, 0x32, 0x81, 0x93, 0x4C, 0xC0, 0x22, 0x45, - 0x28, 0xB9, 0x69, 0x4C, 0x34, 0x46, 0x96, 0xD5, 0x13, 0x3A, 0x41, 0x66, 0xCB, 0x77, 0xA2, 0x95, - 0xBF, 0xC8, 0x5D, 0xAB, 0x31, 0x59, 0x00, 0x71, 0xF6, 0xE6, 0xE7, 0xFF, 0xEA, 0x58, 0xD3, 0xA4, - 0x55, 0x39, 0x9F, 0xA2, 0x02, 0x20, 0xDA, 0xA4, 0x01, 0x34, 0xBF, 0xFF, 0xCA, 0x2F, 0xCA, 0xCA, - 0xCD, 0xC4, 0x1A, 0xA8, 0x8E, 0x4D, 0xC8, 0x01, 0xA0, 0x1D, 0xBB, 0x68, 0xDE, 0x65, 0x60, 0x81, - 0xC1, 0x6F, 0xE6, 0xFF, 0x5A, 0x3A, 0x41, 0x26, 0xC1, 0x1C, 0x54, 0x43, 0xD0, 0x10, 0x97, 0x7F, - 0xFA, 0x26, 0xB0, 0xEF, 0x95, 0x0F, 0x30, 0xC0, 0x8F, 0x4F, 0x5D, 0x65, 0x01, 0xAA, 0x8E, 0xDA, - 0x8D, 0x41, 0x29, 0x6F, 0xFF, 0xE6, 0xF5, 0x11, 0xF0, 0xE2, 0xE1, 0x06, 0x84, 0x01, 0x40, 0xC3, - 0x40, 0x06, 0x74, 0xB0, 0x26, 0x06, 0x00, 0x86, 0x3B, 0x4D, 0x86, 0x83, 0x87, 0x80, 0x50, 0x54, - 0xC2, 0x20, 0x8C, 0xC6, 0xF5, 0xEC, 0x40, 0x84, 0xF7, 0x2F, 0x31, 0xA5, 0x8C, 0x6A, 0xC3, 0xA2, - 0x84, 0x11, 0x88, 0xFF, 0xD8, 0x3A, 0x2E, 0x82, 0x82, 0xD8, 0x99, 0xB6, 0xE0, 0x50, 0xF5, 0xC8, - 0x86, 0x86, 0x7E, 0xA6, 0x7B, 0x88, 0xC7, 0x2A, 0x68, 0xC3, 0x06, 0xDD, 0xBA, 0xED, 0xB8, 0x69, - 0xE5, 0x0F, 0x16, 0x50, 0xC9, 0x35, 0x18, 0xDD, 0xE4, 0xFE, 0x11, 0x12, 0xB8, 0x3D, 0xD0, 0x83, - 0xB6, 0xD2, 0xDA, 0x64, 0x13, 0x0E, 0x46, 0xD2, 0x4A, 0x2B, 0x55, 0xBA, 0x25, 0xA9, 0x41, 0xAE, - 0xC4, 0x5B, 0xB9, 0xF6, 0x1A, 0x6A, 0x74, 0x30, 0x14, 0x56, 0xD7, 0xEF, 0xB0, 0x0C, 0xBB, 0x6F, - 0x25, 0x5B, 0x5F, 0x9F, 0x7F, 0x3F, 0x98, 0xFF, 0xFA, 0x1A, 0xD5, 0xE6, 0xAF, 0xC6, 0xEA, 0x51, - 0xC9, 0x26, 0x6E, 0x7F, 0x29, 0xE5, 0xB4, 0x48, 0x23, 0x70, 0xE5, 0x40, 0x7B, 0xD0, 0x17, 0x0C, - 0xA0, 0x58, 0x1D, 0x8F, 0x00, 0xE7, 0xFF, 0xF3, 0x67, 0x12, 0x42, 0x4E, 0x54, 0x49, 0x35, 0xC1, - 0xEB, 0x50, 0x24, 0x1A, 0x75, 0x2C, 0x3E, 0xDD, 0x06, 0xEF, 0x5F, 0xFA, 0xBB, 0x26, 0x81, 0x00, - 0xCC, 0x98, 0xC1, 0x68, 0x70, 0x31, 0xFF, 0xEA, 0x00, 0x00, 0x05, 0x01, 0xF5, 0x55, 0x61, 0xD0, - 0x41, 0xBB, 0x74, 0x46, 0x84, 0x19, 0x08, 0xC0, 0x26, 0x15, 0x08, 0x1A, 0x88, 0x26, 0x70, 0x58, - 0x83, 0xAD, 0x19, 0xA3, 0x86, 0x3A, 0x21, 0x81, 0x16, 0x68, 0xCC, 0x9D, 0xFF, 0xFB, 0x90, 0x64, - 0x12, 0x0F, 0xC4, 0x2F, 0x34, 0x4D, 0x1B, 0x9A, 0x79, 0xF0, 0x31, 0xA8, 0xC9, 0x4D, 0x24, 0x0A, - 0x0C, 0x0F, 0xE4, 0xD1, 0x32, 0x0E, 0x65, 0x2D, 0xC0, 0xC7, 0x1A, 0x63, 0x80, 0x90, 0x28, 0x30, - 0x51, 0xA7, 0x48, 0xB8, 0x09, 0x49, 0x0B, 0x31, 0x02, 0x45, 0x32, 0x86, 0xC0, 0x20, 0x02, 0xC4, - 0xC0, 0x51, 0x1C, 0x0C, 0x5B, 0xA6, 0x4E, 0xD6, 0x96, 0x22, 0x24, 0xAF, 0xE8, 0x38, 0x04, 0x08, - 0x98, 0x9C, 0x94, 0x7F, 0x04, 0x8C, 0x4C, 0xD2, 0xB1, 0x0B, 0x55, 0x96, 0x43, 0xD4, 0xFF, 0x4F, - 0x42, 0x53, 0x85, 0x6B, 0x8B, 0x71, 0x84, 0xFD, 0x88, 0xC1, 0x40, 0x65, 0xBE, 0xEC, 0xC9, 0x13, - 0xC0, 0xFF, 0x43, 0xBF, 0xF8, 0xC4, 0xDE, 0xD1, 0xF1, 0xE0, 0xCF, 0x02, 0x5D, 0x42, 0xFF, 0xE6, - 0x33, 0xD7, 0xED, 0xAA, 0x48, 0x6F, 0xA7, 0x48, 0xC0, 0xA6, 0x18, 0x5A, 0x9C, 0x63, 0xDF, 0xFD, - 0x7F, 0xD2, 0x00, 0x00, 0x00, 0x20, 0x03, 0x00, 0x0B, 0x00, 0x04, 0x7E, 0x1F, 0x17, 0xE6, 0xE6, - 0x3F, 0xCC, 0x73, 0x0C, 0xDF, 0xFF, 0x4A, 0xD0, 0xC8, 0x8A, 0x5F, 0x0C, 0x8F, 0x7F, 0x35, 0xCF, - 0x7F, 0xFC, 0x63, 0x4E, 0x79, 0x7A, 0x12, 0x7B, 0x55, 0xBF, 0xFF, 0xCC, 0x7C, 0x85, 0x4E, 0x90, - 0x1F, 0xFB, 0xA1, 0x77, 0x55, 0x23, 0x80, 0xA3, 0xB3, 0x09, 0x35, 0x0D, 0xDC, 0x2D, 0x07, 0x07, - 0xCC, 0xAC, 0x16, 0x33, 0xD7, 0x30, 0x04, 0xB5, 0x32, 0x81, 0x5C, 0x2A, 0x27, 0x0A, 0x25, 0x4C, - 0x9E, 0x3C, 0x31, 0x40, 0x88, 0x04, 0x70, 0x27, 0x9C, 0x04, 0xAA, 0xA6, 0x30, 0x4B, 0x66, 0x31, - 0xF4, 0x20, 0x11, 0x88, 0x7D, 0x06, 0xD2, 0x22, 0x91, 0x69, 0x0B, 0x3B, 0x9C, 0x41, 0x12, 0x1C, - 0x97, 0x5C, 0x69, 0xE7, 0x52, 0xBA, 0x12, 0xF1, 0x22, 0x5B, 0x37, 0x90, 0xE4, 0xA1, 0xF2, 0x88, - 0x26, 0x4B, 0x0C, 0xC0, 0x32, 0x94, 0x9F, 0x46, 0x9B, 0x7C, 0x94, 0xC1, 0xF0, 0x96, 0x47, 0x28, - 0xA1, 0xA1, 0x7F, 0x9E, 0x98, 0xB2, 0x33, 0x2B, 0xE7, 0x67, 0x9F, 0xF5, 0xA7, 0xFC, 0xBF, 0xC8, - 0x1A, 0x51, 0xDB, 0x9F, 0xF4, 0x0A, 0x92, 0x2C, 0x58, 0x02, 0x68, 0xDA, 0x12, 0x82, 0xD1, 0xE4, - 0xE6, 0x62, 0xD8, 0x6D, 0x8A, 0x0A, 0xC3, 0xEF, 0xD1, 0xF6, 0xA0, 0x30, 0x1A, 0x05, 0x40, 0x14, - 0x24, 0x82, 0xCF, 0xFD, 0xFD, 0xC4, 0x85, 0x11, 0xDB, 0x9A, 0x2D, 0x08, 0x41, 0x4F, 0x8C, 0x8B, - 0x8F, 0x0B, 0xFF, 0xD2, 0xA5, 0x03, 0x6C, 0x16, 0x07, 0x62, 0x40, 0x8B, 0xAB, 0x1E, 0x4E, 0x78, - 0x83, 0x27, 0xFF, 0xF2, 0x2A, 0x80, 0x00, 0x05, 0xA5, 0xE0, 0x60, 0x22, 0xD9, 0x96, 0xE9, 0xE6, - 0x5F, 0x10, 0xA4, 0xD1, 0x8F, 0x96, 0x46, 0x4B, 0x40, 0x9C, 0x85, 0x66, 0xF7, 0xA1, 0xBF, 0x58, - 0x65, 0x61, 0x19, 0x56, 0xA6, 0x1C, 0xA1, 0xA5, 0x0C, 0x71, 0x02, 0x98, 0xC0, 0x82, 0xC0, 0x0C, - 0x40, 0x30, 0x51, 0x4B, 0x88, 0xDA, 0xDE, 0x82, 0x87, 0xB6, 0x47, 0xC8, 0x3E, 0xFF, 0xFB, 0x92, - 0x64, 0x1C, 0x0F, 0x73, 0xDF, 0x34, 0x4D, 0x2B, 0x9A, 0x79, 0xD0, 0x31, 0x26, 0x79, 0x00, 0x04, - 0x08, 0x0C, 0x4F, 0x68, 0xCD, 0x34, 0x0E, 0xE5, 0xE9, 0x18, 0xC0, 0x9A, 0x25, 0x14, 0x23, 0x15, - 0xF0, 0xD5, 0x6C, 0x87, 0xA0, 0xB5, 0x15, 0x6C, 0xEF, 0xCB, 0x81, 0x2F, 0x38, 0x94, 0x82, 0xD0, - 0x9B, 0xFC, 0x4E, 0x17, 0x07, 0x6A, 0x90, 0xA0, 0x3F, 0x32, 0x9A, 0x09, 0xCB, 0x6D, 0x16, 0xC5, - 0x01, 0x5A, 0xF9, 0x3C, 0xB8, 0x63, 0x39, 0xD6, 0x54, 0x4F, 0x47, 0x76, 0x75, 0xFF, 0x9F, 0x5F, - 0xFF, 0x8D, 0xD2, 0x06, 0xF3, 0xE2, 0xFC, 0x44, 0x56, 0x47, 0x67, 0xBC, 0x19, 0xA2, 0xB2, 0xB8, - 0xC5, 0xFD, 0xB7, 0x7B, 0x80, 0x10, 0xE5, 0x9E, 0x2F, 0xFF, 0xA5, 0x71, 0x8B, 0xB9, 0xE5, 0x16, - 0x18, 0x02, 0x62, 0x68, 0x3E, 0xC5, 0xF2, 0xC4, 0x79, 0x72, 0xC5, 0xC6, 0x26, 0xF6, 0xA9, 0x01, - 0xC9, 0xD4, 0xE9, 0x23, 0x0E, 0x1F, 0xF3, 0xAD, 0xED, 0xFF, 0x1F, 0xFF, 0x16, 0xE3, 0x05, 0x0E, - 0x6D, 0x9B, 0xCA, 0x36, 0x06, 0x10, 0x8A, 0xAE, 0xF4, 0x72, 0x31, 0x52, 0x10, 0x28, 0x1E, 0xCC, - 0x0D, 0x06, 0x81, 0x24, 0x91, 0x90, 0xE4, 0xC8, 0x88, 0x23, 0x31, 0x58, 0x53, 0x05, 0x2A, 0x64, - 0x42, 0x6A, 0x1A, 0x6A, 0xB6, 0x74, 0x52, 0x73, 0xB6, 0x20, 0x10, 0xC5, 0x19, 0x32, 0x91, 0xC6, - 0xFB, 0x28, 0x55, 0x31, 0xFC, 0x9B, 0x2B, 0x3B, 0x11, 0x58, 0xCC, 0xC3, 0xAD, 0x0F, 0x37, 0x46, - 0xF1, 0xB0, 0x2E, 0x4C, 0x2E, 0x42, 0x3E, 0x13, 0x0E, 0x56, 0xA1, 0x3B, 0x7C, 0x68, 0x37, 0x12, - 0xB6, 0xF7, 0xAE, 0x64, 0x7B, 0xC5, 0xDB, 0xB5, 0x5B, 0xF8, 0xAE, 0x70, 0x4F, 0x60, 0x4E, 0x0B, - 0x81, 0x24, 0x3F, 0x4B, 0xD9, 0x0A, 0x8F, 0xFF, 0xAD, 0x3B, 0x5E, 0x3F, 0xC3, 0x9E, 0x2A, 0xC9, - 0x98, 0x0E, 0x7F, 0x09, 0xF6, 0xD8, 0xD2, 0xB6, 0xA3, 0x5B, 0x56, 0x95, 0x33, 0x6B, 0xC9, 0xB8, - 0xE9, 0xC4, 0x60, 0xE2, 0xFD, 0x24, 0xBF, 0xFC, 0x5A, 0xC3, 0xF3, 0xD3, 0xDD, 0x2B, 0x20, 0xC7, - 0x21, 0xA6, 0x10, 0x5F, 0xEF, 0xF2, 0xDA, 0x0B, 0xEE, 0x21, 0x01, 0xD0, 0x5D, 0x8B, 0xA7, 0xBF, - 0x52, 0x16, 0x16, 0x2C, 0x1E, 0xEB, 0xC6, 0x8A, 0xB7, 0xFF, 0xC8, 0x48, 0x41, 0x48, 0x4F, 0xD6, - 0x82, 0xB5, 0x7F, 0x04, 0x21, 0xE6, 0x58, 0xA8, 0x67, 0xEE, 0x24, 0x02, 0xC1, 0x41, 0xD3, 0xC3, - 0xDE, 0x35, 0xF7, 0xC3, 0x52, 0x3B, 0x37, 0xB3, 0x29, 0xB0, 0x49, 0x21, 0x30, 0x31, 0x83, 0x8B, - 0x19, 0x51, 0x81, 0xA9, 0x41, 0x19, 0x58, 0x78, 0x70, 0x79, 0xD3, 0x44, 0x41, 0x79, 0x1A, 0x78, - 0x8F, 0x66, 0x79, 0x17, 0x2D, 0x4C, 0x22, 0xD7, 0x58, 0xCC, 0x02, 0xBE, 0x1A, 0x22, 0x73, 0xA9, - 0xD3, 0x2D, 0x79, 0x2B, 0x90, 0x3D, 0x5E, 0xD8, 0xA0, 0x5D, 0x6B, 0xB1, 0x93, 0x34, 0xB9, 0xB6, - 0x9E, 0xAA, 0x71, 0xF6, 0x90, 0x44, 0xA6, 0x9B, 0x15, 0x6B, 0xEC, 0x7A, 0x1D, 0x82, 0xA8, 0xFF, - 0xFB, 0x92, 0x64, 0x2E, 0x8F, 0x34, 0x15, 0x33, 0xCB, 0x83, 0x78, 0x4B, 0xE2, 0x2F, 0xC5, 0xC9, - 0x75, 0x14, 0xC2, 0x96, 0x90, 0x20, 0xD1, 0x2E, 0x0E, 0x69, 0x2D, 0x80, 0xBF, 0x8E, 0x25, 0xE0, - 0x63, 0x98, 0x38, 0xF6, 0xC2, 0x15, 0xF2, 0xEE, 0x52, 0xA6, 0x70, 0xD4, 0xBE, 0x2D, 0xBF, 0xF8, - 0xE9, 0x5C, 0xCD, 0xA6, 0xAC, 0x06, 0x14, 0xDA, 0xC8, 0x27, 0x40, 0xBA, 0x52, 0x1B, 0x28, 0x84, - 0x54, 0x2E, 0x16, 0x8E, 0x76, 0x89, 0x49, 0x2C, 0x78, 0x80, 0x00, 0x01, 0x06, 0x86, 0xFA, 0x44, - 0xC2, 0x3F, 0xE5, 0x61, 0x68, 0x59, 0xA6, 0x51, 0x86, 0x1E, 0x04, 0x72, 0x06, 0x9E, 0x99, 0x87, - 0x92, 0x35, 0x22, 0xA8, 0xD7, 0x46, 0xE1, 0x2F, 0x08, 0x52, 0x9C, 0x4A, 0x5C, 0x59, 0xA0, 0x19, - 0x7C, 0xCD, 0xFF, 0xF5, 0x45, 0xA0, 0xE2, 0xBD, 0x50, 0xE2, 0x52, 0x98, 0xD9, 0xB8, 0x36, 0xD3, - 0x30, 0x60, 0x54, 0xC4, 0x07, 0x70, 0x13, 0x24, 0xCC, 0x6F, 0x21, 0xE4, 0xE0, 0x63, 0xE0, 0x10, - 0x2A, 0x31, 0xE8, 0x60, 0xC6, 0xC6, 0x23, 0x01, 0x20, 0x0C, 0x1E, 0x21, 0x31, 0xC0, 0x05, 0x84, - 0x94, 0x8E, 0x34, 0x27, 0xC0, 0x00, 0x97, 0x81, 0x72, 0x44, 0x05, 0xC3, 0x98, 0xA0, 0x05, 0x35, - 0xD2, 0x01, 0x74, 0x3C, 0x2E, 0x5A, 0xE4, 0x22, 0x30, 0x9C, 0x8A, 0x14, 0x5E, 0x05, 0x31, 0x53, - 0x84, 0x8C, 0x88, 0x4E, 0x3D, 0x0C, 0xC9, 0xDA, 0x87, 0x9B, 0x04, 0x13, 0x29, 0x87, 0x9D, 0xB8, - 0x21, 0x6E, 0x93, 0x01, 0x7E, 0x97, 0xE3, 0x88, 0xA1, 0x33, 0xF9, 0xA4, 0x60, 0xA1, 0x40, 0x64, - 0x01, 0x99, 0x7D, 0xFA, 0xCF, 0x5A, 0xDA, 0xF0, 0x69, 0x66, 0x72, 0x74, 0xE8, 0x7E, 0x54, 0x94, - 0x58, 0xAB, 0xA1, 0x76, 0xAC, 0x92, 0xE9, 0xC3, 0xF4, 0x0C, 0x41, 0x00, 0x26, 0x0E, 0x13, 0x7A, - 0xC0, 0xF1, 0x3B, 0xB7, 0xE8, 0x8C, 0x08, 0x25, 0x0E, 0x51, 0x33, 0x1A, 0x48, 0xF2, 0xEC, 0x3A, - 0x40, 0x40, 0x92, 0x56, 0xF8, 0x69, 0x4E, 0x6B, 0x40, 0xEB, 0x9E, 0xA6, 0x06, 0xE1, 0x60, 0xF8, - 0x71, 0xF7, 0xAE, 0xF9, 0x8B, 0x99, 0x0A, 0x2B, 0x72, 0x15, 0x6E, 0xE2, 0x82, 0x63, 0x15, 0x47, - 0x8C, 0x70, 0x9A, 0x30, 0x00, 0x38, 0x51, 0x3A, 0x64, 0x42, 0x11, 0x98, 0x4B, 0xE6, 0x9C, 0x18, - 0x19, 0xF4, 0x44, 0x61, 0x71, 0x31, 0x8B, 0x89, 0x26, 0x76, 0x01, 0x8B, 0x34, 0x7D, 0x08, 0x1C, - 0x27, 0x22, 0xC8, 0x8C, 0x99, 0xD1, 0x26, 0x2C, 0xD1, 0xC8, 0x11, 0x03, 0x2E, 0x92, 0x12, 0x04, - 0x82, 0x8F, 0x17, 0x48, 0x77, 0x86, 0x91, 0xAB, 0x90, 0x80, 0x5A, 0x33, 0x6D, 0x28, 0xBD, 0x6A, - 0xAF, 0x0B, 0x20, 0x10, 0xA2, 0x8E, 0xA3, 0x64, 0x6B, 0xBD, 0x87, 0x18, 0x2C, 0x95, 0x96, 0xC1, - 0xCC, 0x11, 0xC4, 0x05, 0x0B, 0x89, 0x71, 0x9B, 0xB9, 0x31, 0xC1, 0x25, 0x05, 0x15, 0x13, 0x2B, - 0x64, 0x2F, 0x2E, 0xFE, 0x93, 0x3D, 0x22, 0x3C, 0xAD, 0xB5, 0x23, 0x4D, 0x31, 0xF2, 0xBF, 0xC8, - 0xC0, 0xFF, 0xFB, 0x92, 0x64, 0x3B, 0x8F, 0xC3, 0xF1, 0x33, 0x4B, 0x83, 0x9A, 0x4A, 0xF2, 0x33, - 0x23, 0x69, 0x50, 0x25, 0x66, 0x40, 0x11, 0x10, 0xCD, 0x2A, 0x0E, 0x69, 0x8D, 0x88, 0xD1, 0x8D, - 0x25, 0xC8, 0xC3, 0x98, 0x88, 0xBE, 0x2D, 0x16, 0x6B, 0x7D, 0x5B, 0xE1, 0xB4, 0x36, 0x39, 0x90, - 0x41, 0x0B, 0xC1, 0x90, 0xCA, 0x22, 0x22, 0x22, 0x3B, 0x2C, 0x00, 0x7C, 0xEE, 0x01, 0x56, 0x29, - 0x81, 0x14, 0x4C, 0x13, 0x80, 0x18, 0x59, 0x9B, 0x6D, 0x37, 0xF4, 0xC3, 0x50, 0x0C, 0x14, 0x3E, - 0x8F, 0x1C, 0x97, 0x1E, 0x1A, 0xDC, 0x24, 0x09, 0x3D, 0x8F, 0xEA, 0x06, 0x91, 0xA1, 0x44, 0xD6, - 0xC8, 0xC1, 0x28, 0xCE, 0x62, 0x53, 0x85, 0xC0, 0x44, 0xA1, 0x46, 0x08, 0x42, 0x19, 0x4A, 0x24, - 0x63, 0x15, 0x59, 0x95, 0xC8, 0xA6, 0x51, 0x0F, 0x18, 0x44, 0x66, 0x62, 0x81, 0x31, 0x8A, 0x51, - 0x22, 0x4B, 0x83, 0x1B, 0x84, 0x8D, 0x5D, 0x00, 0x35, 0x03, 0x82, 0xD4, 0xD8, 0x02, 0x38, 0x27, - 0xD6, 0x00, 0x2E, 0x34, 0x0C, 0xF8, 0x39, 0x99, 0x7B, 0xEE, 0x16, 0xA5, 0x83, 0x4A, 0x98, 0xE1, - 0x00, 0x40, 0x30, 0xA5, 0x30, 0xC8, 0xBF, 0x25, 0xC5, 0x60, 0x85, 0x43, 0x81, 0x0D, 0xDA, 0xB5, - 0x34, 0x6A, 0xDA, 0x0D, 0x33, 0x4B, 0xAF, 0xAC, 0xB5, 0x30, 0x44, 0x67, 0x40, 0x55, 0xA3, 0x2F, - 0x0C, 0x99, 0x93, 0xBD, 0xE0, 0x6F, 0x0C, 0xCF, 0x43, 0xB3, 0x55, 0x67, 0x03, 0x36, 0x50, 0x65, - 0x08, 0x33, 0x98, 0x17, 0x4C, 0xCE, 0xF7, 0xC0, 0x60, 0xCD, 0x66, 0x0F, 0x80, 0xBC, 0x7D, 0x7B, - 0xAF, 0xF6, 0x32, 0xCE, 0xC4, 0xBD, 0x9E, 0xC0, 0x02, 0x1C, 0x13, 0x88, 0xEA, 0x26, 0x00, 0x90, - 0x3B, 0x68, 0x4C, 0x20, 0x0C, 0x99, 0x20, 0x81, 0x74, 0x20, 0x82, 0x02, 0xEB, 0x15, 0x4A, 0xC6, - 0x7C, 0x5A, 0x65, 0x2C, 0x63, 0x75, 0xCE, 0xC4, 0x6D, 0x33, 0x19, 0x98, 0x98, 0x98, 0xDE, 0x87, - 0xC9, 0xE1, 0xB7, 0xE7, 0x57, 0xD8, 0x4A, 0xB6, 0x51, 0xEA, 0xFF, 0xC9, 0x2A, 0x00, 0x02, 0x0B, - 0x45, 0x80, 0x89, 0xB5, 0xC9, 0x43, 0x86, 0x83, 0x1D, 0x08, 0xCC, 0x2C, 0x27, 0x34, 0x1C, 0x10, - 0x7A, 0x02, 0x63, 0x71, 0xE9, 0x9C, 0x80, 0x66, 0x34, 0x10, 0x89, 0x24, 0xC5, 0x42, 0x46, 0x3B, - 0x2E, 0x19, 0xAC, 0x58, 0x68, 0x14, 0xA8, 0x08, 0x3C, 0x64, 0xD1, 0xD1, 0x9E, 0x59, 0xFF, 0x00, - 0x1A, 0x39, 0xD5, 0xAE, 0x52, 0xB8, 0xE8, 0x2E, 0x42, 0x20, 0x94, 0x09, 0x51, 0xAD, 0x90, 0x91, - 0x13, 0x80, 0x64, 0x49, 0x54, 0xAD, 0x24, 0x40, 0x24, 0xE2, 0x11, 0x72, 0x79, 0xF4, 0x6E, 0xF0, - 0x4C, 0x0E, 0xF1, 0xBF, 0xEE, 0x03, 0x42, 0x45, 0x15, 0x2B, 0xA7, 0xAE, 0xD3, 0x18, 0xB6, 0x34, - 0x24, 0xCD, 0x0E, 0x45, 0x46, 0x00, 0x62, 0x03, 0x82, 0x04, 0xFC, 0x36, 0xD3, 0x5F, 0xF9, 0x54, - 0xDE, 0xD0, 0x17, 0x18, 0x38, 0x1C, 0x07, 0xD4, 0x2E, 0x6C, 0x93, 0xB9, 0x39, 0xFB, 0x3F, 0xBA, - 0x9A, 0xA6, 0x37, 0xFF, 0xFB, 0x92, 0x64, 0x43, 0x0F, 0x44, 0x36, 0x33, 0xCB, 0x13, 0x99, 0x43, - 0xD4, 0x35, 0x03, 0x29, 0xBA, 0x2D, 0x23, 0x46, 0x0F, 0x98, 0xC1, 0x2E, 0x0E, 0x64, 0xEF, 0x48, - 0xC6, 0x08, 0xA6, 0x68, 0xC3, 0x0C, 0x78, 0xAA, 0x40, 0x00, 0x00, 0x00, 0x26, 0x60, 0x01, 0x1D, - 0x01, 0x87, 0x87, 0x95, 0xBF, 0x1B, 0x0A, 0x04, 0x84, 0xC7, 0x47, 0x45, 0xC0, 0x9A, 0x4B, 0x49, - 0x5C, 0x44, 0x57, 0xC4, 0xD4, 0x02, 0x5A, 0x42, 0x6F, 0x97, 0xCA, 0x50, 0xCB, 0x0E, 0x81, 0x26, - 0xAE, 0x9D, 0x9F, 0xDC, 0x2B, 0x45, 0x29, 0x47, 0xFD, 0x19, 0x34, 0x4A, 0xA4, 0x50, 0x28, 0x61, - 0x10, 0x78, 0xB1, 0x80, 0xC7, 0xC5, 0x13, 0x05, 0x84, 0x8C, 0x28, 0x01, 0x32, 0xE3, 0x48, 0xCC, - 0xA1, 0xD3, 0x08, 0x80, 0x0E, 0x02, 0x13, 0x15, 0x13, 0x99, 0x20, 0x2E, 0x61, 0x40, 0x20, 0xA1, - 0x1C, 0xC7, 0x43, 0x83, 0x4F, 0x2D, 0x80, 0xC0, 0xF3, 0x0B, 0x87, 0x02, 0xD0, 0x93, 0x78, 0x82, - 0xA0, 0x52, 0x04, 0x01, 0x9A, 0x44, 0x2D, 0x66, 0x38, 0xF1, 0x18, 0x82, 0xB5, 0x37, 0x61, 0x0F, - 0x9A, 0xEB, 0x01, 0x87, 0x14, 0x55, 0x94, 0xB0, 0x37, 0x5D, 0x2C, 0x1C, 0xD7, 0x66, 0x07, 0xA6, - 0x5F, 0xEF, 0x33, 0x75, 0x61, 0xCD, 0x2A, 0x14, 0xBA, 0xD0, 0x52, 0x9A, 0xCB, 0xAC, 0xC7, 0xDD, - 0x4A, 0xA1, 0xC6, 0xA8, 0x8E, 0x23, 0x8A, 0xC6, 0xA7, 0x3D, 0x13, 0x5F, 0xD3, 0xF7, 0x13, 0xB0, - 0x8C, 0x24, 0x0A, 0x8C, 0x07, 0x41, 0x8B, 0x78, 0x59, 0x70, 0x0C, 0x00, 0x06, 0x0D, 0x02, 0x21, - 0x8B, 0xB0, 0x83, 0x82, 0x2F, 0xF7, 0xCD, 0x99, 0xC7, 0x34, 0xF9, 0x4E, 0x2C, 0xD4, 0x6E, 0xE3, - 0x96, 0xAB, 0x86, 0x1C, 0xD4, 0x0C, 0x14, 0x13, 0xBD, 0x22, 0x35, 0xBA, 0xD6, 0x29, 0x85, 0xB4, - 0xAA, 0xE6, 0xF6, 0xB2, 0xFE, 0xCF, 0xEB, 0x7F, 0x35, 0xF7, 0x13, 0x00, 0x02, 0x05, 0xBE, 0x82, - 0x53, 0x01, 0x03, 0xCE, 0x16, 0x29, 0x0C, 0x41, 0x94, 0x10, 0x0C, 0x60, 0x43, 0x30, 0x23, 0x5C, - 0xCA, 0xC8, 0x63, 0x58, 0x17, 0x8C, 0x14, 0x34, 0x32, 0x28, 0x00, 0xC3, 0x83, 0xC3, 0x14, 0x04, - 0x0C, 0x96, 0x4F, 0x33, 0x8C, 0xF4, 0xC1, 0xA2, 0x73, 0x1C, 0x8F, 0x82, 0x87, 0x44, 0x55, 0x3B, - 0x66, 0x46, 0x77, 0x0F, 0xD5, 0x4D, 0xC5, 0xF0, 0xCC, 0x87, 0xD3, 0xB6, 0xE8, 0xB7, 0xD9, 0x8B, - 0x80, 0x54, 0x02, 0x64, 0xAA, 0xAA, 0x83, 0x3D, 0xE0, 0x67, 0xAD, 0x66, 0x64, 0xE9, 0xA7, 0x23, - 0x66, 0xB3, 0x0C, 0xB8, 0xB0, 0x4C, 0x18, 0x42, 0xF3, 0xA9, 0x14, 0x22, 0x79, 0x90, 0x2A, 0x27, - 0xD3, 0x1B, 0x4F, 0x27, 0x2C, 0xCA, 0x27, 0x65, 0x0F, 0xBC, 0x2B, 0xF8, 0xF0, 0xC2, 0xAB, 0x94, - 0xA3, 0x20, 0x88, 0x09, 0xFE, 0x15, 0x17, 0x15, 0x07, 0x80, 0xB9, 0xC0, 0x40, 0x3F, 0x09, 0xFC, - 0x52, 0x32, 0x34, 0xFE, 0x59, 0x8E, 0xF8, 0x19, 0xB3, 0xA6, 0xD8, 0x00, 0x0A, 0xC0, 0x00, 0x04, - 0xE3, 0xE0, 0x0A, 0x93, 0xD1, 0xFF, 0xFB, 0x92, 0x64, 0x4D, 0x0F, 0x04, 0x7A, 0x34, 0x4A, 0x93, - 0x98, 0x3B, 0xE4, 0x30, 0x26, 0x19, 0xDD, 0x20, 0x22, 0x8C, 0x10, 0xD4, 0xD3, 0x2C, 0x0D, 0xE9, - 0x6F, 0x90, 0xC6, 0x09, 0xE6, 0xA8, 0x53, 0x09, 0x00, 0xE9, 0x7F, 0xC2, 0x57, 0xF2, 0x03, 0x08, - 0x3A, 0x1B, 0x42, 0xB7, 0x24, 0xC9, 0xD0, 0x26, 0x66, 0x7C, 0x9C, 0x83, 0x97, 0xDF, 0x2F, 0xCD, - 0xFF, 0xDB, 0xF2, 0x98, 0x85, 0x58, 0x41, 0x7C, 0x7F, 0xF9, 0x44, 0x7C, 0x0C, 0xBD, 0x57, 0x1F, - 0x93, 0x0D, 0x08, 0x34, 0x29, 0x60, 0x15, 0xB2, 0x2C, 0x04, 0x1B, 0x9D, 0xA5, 0x29, 0xA8, 0x9E, - 0x1C, 0x0C, 0x08, 0x54, 0x58, 0xD5, 0x81, 0x0C, 0x30, 0xF8, 0xC6, 0x0E, 0x4F, 0x0E, 0xB0, 0xC3, - 0xAA, 0x0B, 0x56, 0x61, 0x43, 0x01, 0x0A, 0xD7, 0xDB, 0x44, 0x45, 0x10, 0x48, 0x23, 0x82, 0x1C, - 0x38, 0xF1, 0x32, 0xC1, 0x09, 0x57, 0x65, 0x07, 0x98, 0xA2, 0x28, 0xBC, 0x09, 0x8A, 0xB4, 0x1A, - 0xE3, 0xAA, 0xFF, 0x36, 0xA8, 0x34, 0xA2, 0xEC, 0x65, 0x1C, 0xAD, 0xC7, 0x6C, 0xF5, 0xB8, 0xC3, - 0xCD, 0x19, 0x22, 0x45, 0x15, 0xCC, 0xD4, 0x64, 0x6A, 0x7D, 0xA5, 0xA8, 0x1B, 0xF4, 0xD9, 0xB9, - 0x23, 0x83, 0x22, 0xF0, 0x1E, 0x76, 0x3F, 0xEA, 0x56, 0x82, 0x6A, 0xEA, 0x54, 0x27, 0x92, 0xA3, - 0xFF, 0x86, 0x81, 0x44, 0xD4, 0xDA, 0x42, 0xAE, 0x39, 0xFE, 0x09, 0x07, 0x93, 0xAF, 0xF3, 0xEE, - 0x64, 0x4E, 0x97, 0xE2, 0xC9, 0x65, 0x08, 0x00, 0x00, 0x10, 0x58, 0x08, 0x6C, 0xCA, 0xC6, 0xE5, - 0x0D, 0x6F, 0x01, 0xA9, 0x15, 0xA6, 0x10, 0xF3, 0xEE, 0x7A, 0xB3, 0xB8, 0x73, 0x63, 0xC5, 0x41, - 0xE0, 0x74, 0xFC, 0xFC, 0x59, 0x1F, 0xDA, 0x2C, 0x5B, 0xC3, 0x8A, 0xBB, 0x5F, 0xFA, 0x05, 0x0D, - 0x9C, 0x22, 0x27, 0x18, 0x73, 0x61, 0x6A, 0x00, 0x02, 0x0D, 0xB0, 0xD2, 0x14, 0x98, 0x49, 0x7C, - 0xCC, 0x21, 0x40, 0x10, 0x58, 0xCA, 0x06, 0xD3, 0x0F, 0x9F, 0x8C, 0x82, 0x2C, 0x30, 0x4B, 0x70, - 0xC3, 0xC2, 0xC3, 0x04, 0x87, 0x81, 0x42, 0xE3, 0x0C, 0x11, 0x4C, 0x60, 0x08, 0x36, 0x09, 0x48, - 0xC9, 0x42, 0xB3, 0x07, 0x86, 0xD7, 0xA0, 0xCC, 0x43, 0x47, 0x3B, 0x83, 0x0A, 0x9F, 0x6E, 0x0A, - 0x80, 0x06, 0x84, 0x40, 0x3A, 0xB5, 0x2C, 0x0C, 0x5A, 0x28, 0xDB, 0xF1, 0x53, 0x23, 0x4A, 0xED, - 0xA2, 0x44, 0x23, 0x48, 0x34, 0x0F, 0x1A, 0x09, 0xAB, 0x43, 0x8F, 0x7E, 0x54, 0xE9, 0x4D, 0x3F, - 0x0F, 0x0E, 0x82, 0x64, 0x8C, 0x9C, 0x75, 0x04, 0x43, 0xE0, 0xE6, 0x24, 0x53, 0x5E, 0xA5, 0xAB, - 0x7A, 0x14, 0xEB, 0x52, 0xC9, 0xA1, 0xDB, 0x1E, 0xA0, 0xF2, 0x46, 0xCB, 0x8F, 0x24, 0x50, 0x89, - 0x12, 0x5B, 0xFF, 0xE3, 0xC1, 0xD0, 0x27, 0x25, 0x97, 0x6A, 0x10, 0xC5, 0x25, 0x53, 0x7E, 0xE5, - 0xDD, 0xFE, 0x97, 0x6C, 0x42, 0x57, 0x7A, 0xD0, 0xB4, 0x0E, 0x40, 0x00, 0x00, 0x0D, 0xE0, 0x44, - 0x92, 0xFB, 0xE8, 0xED, 0xD0, 0xD4, 0x1F, 0xFF, 0xFB, 0x92, 0x64, 0x50, 0x06, 0x04, 0x82, 0x34, - 0x4A, 0x93, 0x99, 0x5B, 0xE4, 0x32, 0x68, 0xF9, 0xBD, 0x08, 0x23, 0xAC, 0x11, 0xE8, 0xC9, 0x28, - 0xCE, 0x69, 0x6D, 0xC0, 0xCB, 0x23, 0xA8, 0x28, 0xC0, 0x88, 0x7B, 0xD8, 0x15, 0x91, 0x00, 0x43, - 0x7A, 0x33, 0x86, 0xB0, 0xDF, 0xA8, 0x11, 0xB8, 0x64, 0x2F, 0xEB, 0xF2, 0xFF, 0xCD, 0xBC, 0xBE, - 0x45, 0xE3, 0xFF, 0xFB, 0xB3, 0xD5, 0x28, 0x93, 0xA0, 0xEF, 0xA2, 0x7E, 0x74, 0x4C, 0x03, 0x02, - 0xE5, 0x6A, 0x40, 0x93, 0x49, 0xC7, 0xB6, 0x42, 0xC5, 0xA0, 0x11, 0xD8, 0x31, 0x44, 0x61, 0x36, - 0x89, 0xAC, 0xCA, 0xA6, 0x2A, 0x7B, 0x99, 0x0C, 0x0E, 0x63, 0x63, 0x89, 0x84, 0x09, 0x66, 0x58, - 0x01, 0x1A, 0x25, 0xD6, 0x61, 0x0E, 0x1B, 0xC6, 0x06, 0x55, 0xC9, 0xC4, 0x14, 0x3C, 0xB1, 0x84, - 0x34, 0xE0, 0x29, 0x73, 0x80, 0x28, 0x70, 0x01, 0x40, 0xF9, 0x0C, 0xF4, 0x51, 0x1D, 0x8B, 0xC4, - 0x09, 0x09, 0x1A, 0x2D, 0xDA, 0xCB, 0x60, 0xED, 0x44, 0x50, 0x02, 0x2B, 0x2E, 0x44, 0xBF, 0x4D, - 0x62, 0xD1, 0x44, 0x2E, 0xBC, 0x29, 0xD6, 0xBE, 0x65, 0xE0, 0x90, 0xA2, 0xCC, 0xD6, 0xFC, 0xBD, - 0x83, 0x2B, 0x1B, 0x02, 0x65, 0xD1, 0x6C, 0xB3, 0x6E, 0xAE, 0x7C, 0xB5, 0xE0, 0x7D, 0x73, 0x83, - 0xAB, 0x78, 0x0F, 0x81, 0x3F, 0x86, 0xB4, 0xC0, 0xDF, 0xFF, 0xFF, 0x3E, 0x4D, 0x1E, 0x81, 0xC8, - 0xA7, 0x6A, 0x5A, 0xA4, 0x80, 0xED, 0x9C, 0x03, 0x15, 0xFF, 0xAF, 0xE8, 0xDD, 0x82, 0x90, 0x80, - 0x09, 0x21, 0x28, 0x0E, 0x0A, 0x36, 0xEF, 0x64, 0xF1, 0xFF, 0x63, 0xEB, 0x6A, 0x2F, 0xFB, 0x7B, - 0xC9, 0x10, 0xCA, 0x92, 0xB2, 0x93, 0x3B, 0xB2, 0x53, 0xFF, 0xBF, 0xFF, 0xFF, 0xA2, 0x93, 0xDE, - 0x6E, 0x96, 0xF5, 0x08, 0x25, 0x18, 0xE4, 0xD9, 0xD0, 0xB2, 0x83, 0x55, 0x6C, 0xE0, 0xDC, 0x7D, - 0x01, 0x1F, 0x02, 0x00, 0xF3, 0x0A, 0x24, 0x3C, 0xAC, 0xD3, 0x47, 0x22, 0x33, 0xF3, 0x03, 0x2A, - 0x2A, 0x39, 0x4F, 0x83, 0xCB, 0x1E, 0x04, 0xA7, 0x1A, 0x40, 0x10, 0x31, 0xE0, 0x2E, 0x32, 0x6C, - 0xA6, 0xA2, 0x10, 0xE3, 0xEA, 0xE1, 0x30, 0xF0, 0x03, 0x1F, 0x07, 0x16, 0x18, 0x0E, 0xB7, 0x60, - 0xE2, 0x00, 0x72, 0xFD, 0x9B, 0x35, 0x97, 0x30, 0xA1, 0x26, 0x58, 0xAC, 0x49, 0xA7, 0xA1, 0x61, - 0x10, 0x40, 0xA2, 0x83, 0x80, 0x96, 0xA1, 0x3A, 0xDA, 0x88, 0xC0, 0xC1, 0x23, 0x20, 0x89, 0x3D, - 0xDA, 0xAA, 0x99, 0xC2, 0x6F, 0x36, 0x34, 0x45, 0x5F, 0x28, 0xC4, 0xC8, 0xCC, 0x01, 0x1D, 0xC6, - 0x67, 0xA4, 0x82, 0x77, 0x5D, 0xA0, 0x35, 0xCA, 0xE0, 0x96, 0x4E, 0x10, 0x3E, 0xA8, 0x1D, 0x1E, - 0x07, 0x43, 0x3D, 0x42, 0x1A, 0xFF, 0xFF, 0xC8, 0xA3, 0xA4, 0x88, 0x46, 0x25, 0x0D, 0x63, 0x79, - 0xB9, 0xF6, 0x10, 0xD9, 0x79, 0x42, 0x15, 0xFF, 0xD1, 0x52, 0xAF, 0x9B, 0x40, 0x10, 0x20, 0x00, - 0x11, 0x98, 0x0E, 0x92, 0xC4, 0x87, 0x5A, 0x11, 0xC3, 0xFF, 0xFB, 0x92, 0x64, 0x4C, 0x8F, 0x04, - 0x60, 0x33, 0xCA, 0x0B, 0x79, 0x5C, 0x44, 0x31, 0xC3, 0x49, 0xCA, 0x18, 0x23, 0xA0, 0x11, 0xEC, - 0xCF, 0x24, 0x0E, 0x61, 0xF2, 0xD0, 0xAD, 0x81, 0x28, 0xA4, 0x21, 0x08, 0x06, 0x67, 0x2D, 0x35, - 0xFE, 0x51, 0x31, 0x2B, 0xB7, 0x24, 0x54, 0xDD, 0x77, 0xB0, 0x5A, 0xAA, 0xF1, 0x3E, 0x7C, 0xB1, - 0x0C, 0x42, 0xDD, 0xE8, 0xFA, 0xBF, 0xAB, 0x7D, 0xFE, 0xAD, 0x07, 0x9F, 0x8B, 0xA5, 0x4F, 0x7A, - 0x58, 0x46, 0x34, 0xD6, 0x10, 0x92, 0x76, 0xDF, 0xF1, 0x8B, 0x00, 0x46, 0x2E, 0x0F, 0x18, 0x41, - 0x98, 0x69, 0x15, 0x12, 0x9D, 0x18, 0x5C, 0xD0, 0x2C, 0x6B, 0x30, 0x79, 0x60, 0x94, 0xE0, 0x58, - 0x3A, 0x9C, 0x84, 0x38, 0x76, 0x78, 0x71, 0x08, 0xB8, 0xC9, 0x84, 0xB3, 0x00, 0x18, 0x4C, 0x7C, - 0x34, 0x30, 0x50, 0x09, 0x98, 0x0A, 0x81, 0x4C, 0xFE, 0x1A, 0x2F, 0x22, 0xD4, 0x48, 0x24, 0x22, - 0x4F, 0xD4, 0xE7, 0x21, 0xD0, 0xFD, 0x1B, 0x32, 0x7A, 0x88, 0x6A, 0x24, 0x26, 0xA2, 0xB0, 0xE4, - 0xC7, 0x67, 0xC4, 0xC7, 0x56, 0xC1, 0xA2, 0x63, 0x5B, 0x06, 0x10, 0xE4, 0x88, 0x96, 0x22, 0x10, - 0x3E, 0x2B, 0xB5, 0x2F, 0x04, 0x00, 0x28, 0x13, 0xDB, 0x53, 0xE0, 0xCC, 0x2F, 0xF7, 0x92, 0x52, - 0xD5, 0xD6, 0xFE, 0x54, 0x91, 0x8B, 0xE3, 0xAD, 0xFB, 0x3E, 0xF9, 0xFB, 0xF4, 0xA6, 0x6F, 0x2A, - 0x72, 0x77, 0x2A, 0x1A, 0xCF, 0x97, 0xDF, 0x63, 0xF5, 0x4A, 0x98, 0xDD, 0xDF, 0xFF, 0xF7, 0xDC, - 0xE4, 0x68, 0x20, 0x22, 0x84, 0xAC, 0x01, 0x41, 0x38, 0x21, 0xE4, 0x85, 0x9C, 0xDA, 0x92, 0x94, - 0x50, 0xF3, 0xA6, 0xC2, 0x43, 0x8D, 0x69, 0x91, 0x43, 0x75, 0xD6, 0x63, 0x90, 0xBB, 0xD4, 0x48, - 0xD9, 0x87, 0x42, 0x8B, 0xF9, 0x77, 0x4B, 0x65, 0x9F, 0xCB, 0x47, 0xC1, 0x05, 0x5D, 0xA8, 0xE4, - 0x88, 0x87, 0xCC, 0x4A, 0x9B, 0x40, 0x04, 0x61, 0xC0, 0xB0, 0x22, 0x30, 0x66, 0xD7, 0x09, 0x8C, - 0x4C, 0xC6, 0xF5, 0x05, 0x87, 0x2C, 0xCC, 0x42, 0xBD, 0x31, 0x90, 0xBC, 0xC0, 0x03, 0x13, 0x31, - 0x22, 0x8E, 0xFD, 0x01, 0x30, 0x90, 0x00, 0xC5, 0x02, 0x63, 0x26, 0x68, 0xED, 0x0D, 0x05, 0x0F, - 0x02, 0x08, 0x30, 0xE2, 0x49, 0x42, 0x25, 0xD1, 0x81, 0x02, 0x24, 0x05, 0xB9, 0x21, 0x2C, 0xB6, - 0x41, 0x41, 0x8A, 0x56, 0xBB, 0x52, 0x35, 0x1C, 0x99, 0x53, 0x09, 0x41, 0x64, 0xC6, 0x76, 0x5B, - 0x20, 0x84, 0x03, 0xB9, 0x3F, 0x69, 0x9E, 0x2C, 0x0D, 0xE2, 0x00, 0x2A, 0x6E, 0x6B, 0xCC, 0xA1, - 0x13, 0xAE, 0x80, 0x37, 0x19, 0x07, 0xDE, 0xA1, 0xC1, 0xF5, 0x79, 0x2B, 0x2B, 0xBB, 0xE4, 0xDC, - 0x0E, 0xB0, 0xCB, 0xFF, 0xC8, 0x97, 0x98, 0x16, 0xB0, 0x76, 0x30, 0xA8, 0x1D, 0x1E, 0x34, 0x3E, - 0x1B, 0x22, 0xB5, 0x6D, 0x0F, 0xD6, 0x09, 0x8B, 0x80, 0x05, 0x86, 0x4F, 0xAD, 0x2E, 0xF3, 0x8A, - 0x01, 0xEA, 0x97, 0x6A, 0x04, 0x78, 0x90, 0x75, 0x5C, 0x7D, 0x4B, 0xFF, 0xFB, 0x92, 0x64, 0x4F, - 0x0E, 0x04, 0x59, 0x33, 0xC9, 0x03, 0x9A, 0x5B, 0xD0, 0x33, 0x83, 0x49, 0x52, 0x18, 0x66, 0x44, - 0x10, 0x70, 0xC3, 0x28, 0x2E, 0x61, 0x2F, 0x50, 0xD1, 0xA4, 0x26, 0xB4, 0x53, 0x0A, 0x48, 0x0C, - 0x82, 0xBB, 0xC2, 0xCB, 0xFA, 0x9B, 0xBE, 0xB3, 0xBC, 0xDB, 0x28, 0xA0, 0x29, 0xBA, 0xC7, 0xA4, - 0xA6, 0x8F, 0xEA, 0x28, 0xD0, 0xFE, 0x58, 0x1F, 0xF2, 0x9D, 0x6D, 0x76, 0x5B, 0x96, 0x9F, 0x59, - 0x24, 0xB4, 0x86, 0x09, 0x0C, 0x9E, 0x04, 0x62, 0x0E, 0x82, 0x8F, 0x12, 0x4C, 0x2C, 0x7E, 0x30, - 0x48, 0xFC, 0xD1, 0x63, 0x33, 0x33, 0x19, 0x42, 0x0D, 0x26, 0x3A, 0x4C, 0x18, 0x54, 0x4A, 0x09, - 0x03, 0x98, 0xD0, 0x66, 0x69, 0x96, 0xC1, 0x85, 0xC7, 0x86, 0x02, 0x12, 0x02, 0xC6, 0x0E, 0x92, - 0xCA, 0x47, 0x21, 0xAA, 0x9D, 0x6E, 0xB0, 0xC9, 0x12, 0xA1, 0xA2, 0xC0, 0x72, 0x9A, 0xD2, 0x09, - 0x82, 0x1C, 0x85, 0xA5, 0xD4, 0x63, 0xA4, 0xC6, 0x68, 0xA8, 0x84, 0x80, 0x87, 0xB6, 0x01, 0x45, - 0xA0, 0x16, 0x60, 0xFD, 0xB6, 0x41, 0x00, 0x19, 0x9A, 0xFB, 0x58, 0x11, 0x81, 0x2C, 0xF6, 0xE3, - 0x0C, 0xBF, 0x30, 0x41, 0x15, 0xE4, 0x09, 0x55, 0x1A, 0x4C, 0xDE, 0xFF, 0x78, 0xB5, 0xFF, 0xFF, - 0xF6, 0x47, 0x9D, 0x60, 0x93, 0x9B, 0xA0, 0xC2, 0x76, 0x6C, 0xC2, 0xA9, 0xB3, 0xD4, 0x0A, 0xA7, - 0xFF, 0xC9, 0xF5, 0x20, 0x1C, 0x20, 0x00, 0xC0, 0x06, 0x99, 0x80, 0x16, 0x7F, 0x7A, 0x53, 0xF5, - 0x0C, 0x9E, 0xD8, 0xCD, 0x1C, 0x44, 0x94, 0xDF, 0x9A, 0x5B, 0x66, 0x50, 0xCB, 0xD8, 0xF0, 0x43, - 0x4C, 0xCD, 0x4E, 0x9B, 0xED, 0xC3, 0x7F, 0xAF, 0xFA, 0xFF, 0xF3, 0x1F, 0xFE, 0xDF, 0xE4, 0xB3, - 0x2A, 0xA9, 0x1B, 0xF6, 0x45, 0xAA, 0x46, 0x75, 0x02, 0x1D, 0x98, 0x51, 0x00, 0x54, 0xF9, 0x49, - 0x13, 0x27, 0x04, 0x8C, 0x00, 0x62, 0x30, 0xE0, 0x24, 0xE0, 0xE3, 0xC3, 0x70, 0x8E, 0x0C, 0x32, - 0xC8, 0x02, 0x10, 0x8C, 0x7A, 0x8B, 0x30, 0x58, 0x74, 0xC4, 0x07, 0xE3, 0x15, 0x9D, 0x8E, 0x10, - 0x8F, 0x30, 0x11, 0x08, 0xC6, 0x26, 0xF3, 0x26, 0x87, 0xD3, 0x50, 0x38, 0x56, 0xA5, 0xA2, 0x40, - 0x10, 0x52, 0x38, 0xBB, 0x8A, 0xBC, 0x70, 0x62, 0xF5, 0x5C, 0xAE, 0x28, 0x84, 0xC5, 0xA1, 0xE4, - 0x32, 0x81, 0xD0, 0x22, 0xCB, 0x64, 0x68, 0x0D, 0x81, 0x5B, 0x88, 0x08, 0x05, 0x9E, 0x73, 0xDA, - 0x1D, 0x1A, 0xF8, 0x4A, 0xB0, 0x49, 0x84, 0x76, 0x3D, 0x8E, 0x06, 0x80, 0x0B, 0x63, 0x2B, 0x76, - 0x29, 0x1E, 0x49, 0x46, 0x16, 0x62, 0x70, 0x66, 0x7D, 0x76, 0x6D, 0x78, 0x8A, 0x77, 0xEA, 0x41, - 0x71, 0x59, 0x11, 0xA8, 0xF8, 0xE3, 0xA8, 0xD0, 0x22, 0x12, 0x1F, 0xA4, 0x00, 0x18, 0x70, 0x01, - 0x12, 0xFE, 0x06, 0x4C, 0xFC, 0x03, 0x27, 0xB1, 0x5F, 0xF6, 0xA9, 0x86, 0xAD, 0xE5, 0xB7, 0xA2, - 0xE9, 0x17, 0x89, 0xC3, 0xCF, 0x20, 0xB2, 0x0E, 0xA1, 0x2E, 0x25, 0x93, 0xD1, 0xFF, 0xFB, 0x92, - 0x64, 0x52, 0x8E, 0x64, 0x1E, 0x2F, 0x49, 0x8B, 0x98, 0x3C, 0xC0, 0x33, 0xE3, 0x79, 0x63, 0x04, - 0x06, 0x18, 0x12, 0x18, 0xBF, 0x22, 0x2E, 0xED, 0xAD, 0xD0, 0xBE, 0x1C, 0x67, 0x28, 0x10, 0x8E, - 0x3A, 0xDB, 0x55, 0x6F, 0x56, 0xB5, 0x85, 0x36, 0xA8, 0x3B, 0x79, 0x83, 0xE6, 0x12, 0x59, 0xA5, - 0xE1, 0x61, 0x89, 0x49, 0x1F, 0xD8, 0x68, 0x46, 0x47, 0x9C, 0x33, 0x4B, 0x91, 0x27, 0xC6, 0x20, - 0x89, 0xC6, 0x72, 0x92, 0x66, 0xBA, 0x0A, 0xE6, 0x45, 0x8A, 0x26, 0x1C, 0x3C, 0x22, 0x20, 0x8C, - 0xC1, 0x33, 0x00, 0xB0, 0x04, 0x99, 0x92, 0x4E, 0x99, 0x4E, 0x1B, 0x1D, 0x6A, 0x70, 0x91, 0xA1, - 0xA1, 0xAC, 0x81, 0x9A, 0x4E, 0x38, 0x89, 0x27, 0x48, 0x81, 0x93, 0x28, 0xC1, 0xCA, 0x4C, 0x2C, - 0x04, 0x30, 0x2D, 0x69, 0x84, 0x10, 0x97, 0xB5, 0x48, 0x0E, 0x0A, 0x2C, 0xD8, 0x68, 0x58, 0x0D, - 0x13, 0x44, 0x89, 0x9D, 0x30, 0x20, 0x21, 0x82, 0x86, 0xB8, 0x4C, 0x94, 0x40, 0x16, 0x1C, 0x03, - 0x04, 0x2C, 0xE5, 0x5E, 0xAD, 0xB0, 0xA0, 0xA8, 0x58, 0x34, 0x00, 0xD0, 0xC1, 0x13, 0x1E, 0x03, - 0x43, 0xAB, 0x88, 0xA6, 0x8B, 0x1A, 0x01, 0x42, 0xBC, 0x70, 0x68, 0x8D, 0x8A, 0x15, 0x18, 0x87, - 0xAD, 0xB7, 0x38, 0xDF, 0xD2, 0xD2, 0x31, 0x40, 0xD9, 0x6A, 0x7A, 0x25, 0xD1, 0x46, 0xEF, 0xFA, - 0x37, 0x7A, 0xAC, 0xC2, 0xCC, 0x00, 0xE3, 0x01, 0x89, 0x7F, 0xFE, 0x7D, 0x83, 0xB2, 0x4E, 0xDB, - 0x92, 0x6D, 0xC1, 0x51, 0x42, 0x02, 0xC8, 0xE7, 0xAF, 0xFB, 0xC0, 0xBF, 0x31, 0x0D, 0x78, 0x98, - 0x84, 0xF6, 0xF5, 0x18, 0xFE, 0x54, 0x0E, 0x15, 0x59, 0x05, 0x10, 0x84, 0xC0, 0xCA, 0x5E, 0x35, - 0x5E, 0x22, 0x17, 0x34, 0x00, 0xC7, 0x0A, 0xAC, 0xF8, 0xC1, 0x43, 0xF3, 0xE1, 0x2E, 0x4E, 0x76, - 0x73, 0x03, 0x09, 0xCC, 0x1E, 0x7A, 0x34, 0x07, 0x60, 0x14, 0x35, 0x31, 0x2C, 0xD8, 0xC9, 0x46, - 0x43, 0x0B, 0xB0, 0xCC, 0x78, 0x80, 0x34, 0x81, 0x2C, 0xD9, 0x42, 0x63, 0x8D, 0x90, 0x07, 0x9D, - 0x86, 0x39, 0x55, 0x19, 0x40, 0xB0, 0x60, 0x51, 0x0B, 0xBC, 0xA1, 0x06, 0x03, 0x0C, 0x9A, 0x04, - 0x14, 0xCA, 0x88, 0x40, 0xA8, 0xCE, 0x52, 0x14, 0x13, 0xB2, 0x09, 0x5A, 0x66, 0xAD, 0x58, 0x78, - 0x46, 0x80, 0x81, 0x5D, 0x21, 0x61, 0x1B, 0x91, 0xED, 0x92, 0xAD, 0x26, 0x91, 0x10, 0x9F, 0x59, - 0x85, 0xF3, 0x81, 0x46, 0x92, 0xD3, 0x42, 0x54, 0x9D, 0x31, 0xE6, 0x97, 0xB9, 0xD6, 0x24, 0xD6, - 0xDA, 0xD6, 0x72, 0x45, 0xDB, 0x9C, 0x8A, 0x8E, 0x18, 0xEB, 0x27, 0x6F, 0xEB, 0xFF, 0x09, 0x82, - 0xA8, 0xDC, 0x3E, 0xFF, 0x77, 0xB5, 0xCA, 0x4F, 0x90, 0xC4, 0xF6, 0x00, 0x00, 0x00, 0x05, 0x57, - 0x81, 0x08, 0x23, 0x49, 0x8F, 0x21, 0x0E, 0x64, 0x85, 0xB4, 0xCD, 0x3A, 0x2A, 0xD9, 0x6A, 0x84, - 0x60, 0xEC, 0x9A, 0xE7, 0x5E, 0xB4, 0x6F, 0xFF, 0xCB, 0xFF, 0x6A, 0x7C, 0xA9, 0xF6, 0x67, 0xFF, - 0xFB, 0x92, 0x64, 0x55, 0x8E, 0x44, 0x33, 0x2F, 0xC9, 0x93, 0x98, 0x54, 0xC0, 0x32, 0xC8, 0x79, - 0xAA, 0x08, 0x02, 0x1A, 0x0F, 0x68, 0xBD, 0x2C, 0x4E, 0x65, 0x0F, 0x40, 0xCE, 0x94, 0x65, 0xA8, - 0x50, 0x08, 0xD8, 0x45, 0x7A, 0x5A, 0x6E, 0x63, 0x99, 0xC1, 0x29, 0x8B, 0xEC, 0x0C, 0xF2, 0x68, - 0x0B, 0x1E, 0x14, 0xCC, 0x6C, 0xC2, 0xE2, 0x23, 0x40, 0x8F, 0xCD, 0x4E, 0x22, 0x0C, 0x0F, 0x22, - 0x51, 0xA4, 0x7A, 0xA6, 0x7D, 0x12, 0x99, 0x4D, 0x22, 0x65, 0xB1, 0x69, 0x9B, 0x8E, 0x46, 0x03, - 0x0C, 0x98, 0x9C, 0x4E, 0x60, 0x63, 0x89, 0xAB, 0x15, 0x26, 0x7B, 0x24, 0x99, 0x50, 0x5C, 0x22, - 0x24, 0x16, 0xB2, 0x11, 0x8C, 0x28, 0x4A, 0xC8, 0x88, 0x44, 0xEB, 0x87, 0x22, 0xE5, 0x06, 0x41, - 0x91, 0xE5, 0x1F, 0x79, 0x69, 0x5A, 0xE3, 0x3F, 0x76, 0xA7, 0x16, 0x19, 0x28, 0xE5, 0x55, 0xE1, - 0xC7, 0x9A, 0x10, 0xD0, 0x1C, 0xB6, 0xCD, 0x14, 0x52, 0x80, 0x42, 0x02, 0xA1, 0xAD, 0xE9, 0x53, - 0x08, 0x9E, 0x83, 0x98, 0x56, 0x9C, 0x38, 0x7C, 0x1D, 0x0B, 0xD5, 0xFF, 0x35, 0xD3, 0xBB, 0x57, - 0x7F, 0xFF, 0x11, 0x82, 0xB0, 0x6E, 0x1F, 0x05, 0x3A, 0x93, 0xFE, 0xAD, 0x80, 0x40, 0x00, 0x10, - 0x38, 0x04, 0x29, 0x68, 0x46, 0xF0, 0x1D, 0xC2, 0x03, 0x46, 0x04, 0xAD, 0x62, 0x50, 0x04, 0x2A, - 0x16, 0x8C, 0x38, 0x72, 0x10, 0xE3, 0xB8, 0x0D, 0x51, 0xF6, 0x7C, 0xDB, 0x5D, 0x09, 0x23, 0xDF, - 0xCE, 0x2F, 0xD6, 0xFF, 0x6B, 0x14, 0x96, 0x20, 0x5D, 0x99, 0x57, 0xBD, 0xD5, 0x1D, 0x86, 0x68, - 0x01, 0x26, 0x52, 0xB4, 0xC2, 0xA0, 0xC4, 0xC8, 0xB6, 0x10, 0x31, 0xCF, 0x30, 0x24, 0x0F, 0x33, - 0x24, 0x3E, 0x3B, 0xC0, 0x31, 0x39, 0x3C, 0x82, 0x30, 0x78, 0xA8, 0x30, 0x8C, 0xA3, 0x30, 0x6D, - 0xFD, 0x33, 0x0C, 0x5D, 0x33, 0x40, 0x60, 0x37, 0x58, 0x89, 0x33, 0x06, 0xAC, 0x30, 0x50, 0xB3, - 0x30, 0x78, 0x5C, 0x34, 0x91, 0x53, 0xEE, 0x56, 0x1E, 0x2D, 0x31, 0x46, 0x40, 0x65, 0xB0, 0x78, - 0x01, 0x10, 0xA4, 0x25, 0x95, 0x4A, 0x84, 0x65, 0x77, 0x57, 0x61, 0x82, 0x08, 0x5B, 0x49, 0xC1, - 0xD0, 0xA7, 0x3D, 0xB2, 0x2A, 0x2B, 0x41, 0x60, 0x02, 0x0C, 0x86, 0x00, 0x00, 0x07, 0x4F, 0xC4, - 0x53, 0x5E, 0x89, 0x7A, 0x3A, 0x7D, 0x49, 0xC7, 0x82, 0xA1, 0x0D, 0x7C, 0x23, 0x20, 0x78, 0x30, - 0x7C, 0x38, 0xA5, 0x4F, 0xE6, 0x15, 0xF1, 0xC3, 0x6A, 0x3F, 0x43, 0x94, 0xA1, 0x4C, 0x1A, 0x5D, - 0xDE, 0xEA, 0x37, 0x76, 0x46, 0xFF, 0xD3, 0xFE, 0xD9, 0x04, 0xE7, 0xEE, 0xA6, 0xB9, 0xFF, 0xFE, - 0xF0, 0x42, 0x60, 0x08, 0x14, 0x80, 0x33, 0x94, 0xE2, 0xE1, 0xFF, 0xFB, 0x96, 0x47, 0x2F, 0x6A, - 0xC7, 0xCF, 0x5D, 0x51, 0x61, 0xA8, 0xDE, 0x00, 0xC0, 0x00, 0x00, 0x01, 0x04, 0x2F, 0x02, 0x4E, - 0x41, 0x2F, 0x44, 0x25, 0x89, 0xD5, 0xA8, 0xC5, 0x54, 0x97, 0xD2, 0x58, 0x88, 0xC0, 0x93, 0x3E, - 0xE6, 0xFF, 0xFB, 0x92, 0x64, 0x60, 0x8F, 0x05, 0x37, 0x34, 0x48, 0x0B, 0xBB, 0xD3, 0x80, 0x2C, - 0xC3, 0x39, 0xBD, 0x04, 0x05, 0x36, 0x13, 0x08, 0xD3, 0x24, 0x0E, 0xE9, 0xF1, 0x10, 0xCB, 0x10, - 0xE7, 0x34, 0x20, 0x8D, 0x78, 0xEE, 0x67, 0xF5, 0xF4, 0xC5, 0x91, 0xA8, 0x89, 0x6A, 0x64, 0x4B, - 0x99, 0x24, 0x52, 0x91, 0x85, 0x8B, 0x97, 0x7B, 0x94, 0x9C, 0xA6, 0x02, 0x81, 0x86, 0xBC, 0x14, - 0x06, 0x25, 0x82, 0x00, 0x90, 0x84, 0xC7, 0xE1, 0x0C, 0xD3, 0x7B, 0xF0, 0xC6, 0x11, 0x48, 0x51, - 0x29, 0x30, 0x50, 0x42, 0x32, 0x41, 0x66, 0x10, 0x86, 0x60, 0x65, 0xFC, 0xC0, 0x81, 0x28, 0xD5, - 0xC5, 0xAC, 0xC2, 0x80, 0x5C, 0xC0, 0xC1, 0x74, 0xC3, 0x60, 0x78, 0xC8, 0x20, 0xC4, 0xB3, 0x60, - 0xA0, 0xD4, 0xC5, 0x41, 0x36, 0x64, 0x42, 0x04, 0x3C, 0x09, 0x88, 0x03, 0x01, 0x02, 0x33, 0xC0, - 0x41, 0x10, 0x70, 0x38, 0xA2, 0x76, 0x98, 0xC9, 0xED, 0x02, 0x3E, 0x28, 0x64, 0x0C, 0x31, 0xD1, - 0x79, 0x5A, 0x52, 0x49, 0xF6, 0x1E, 0x5B, 0x89, 0x47, 0x42, 0xC8, 0x48, 0x61, 0x9B, 0x40, 0x8A, - 0x73, 0x8B, 0x72, 0x83, 0x71, 0xA9, 0x33, 0x0E, 0x0A, 0x33, 0x9C, 0xC8, 0x70, 0xAD, 0x5A, 0xF8, - 0x69, 0xBB, 0x43, 0x2B, 0x4F, 0xEA, 0x76, 0x5D, 0xE1, 0x95, 0xB7, 0xFF, 0xF0, 0xBA, 0x70, 0x48, - 0x46, 0x70, 0x24, 0x90, 0xB5, 0xFF, 0xCC, 0xAE, 0xF7, 0x47, 0x5A, 0xFE, 0x2B, 0x72, 0xFA, 0x92, - 0x88, 0x00, 0x0E, 0x00, 0x00, 0x5B, 0x3F, 0x01, 0x5C, 0xD8, 0x66, 0xFF, 0x37, 0x9B, 0x36, 0x8D, - 0x17, 0xF3, 0x1F, 0x9F, 0x91, 0xE8, 0x81, 0xF3, 0xAE, 0xA1, 0x7C, 0x7A, 0x35, 0x54, 0x4E, 0xFB, - 0x0B, 0xBF, 0x49, 0x22, 0x7A, 0x1C, 0x04, 0x47, 0x84, 0xF2, 0x2C, 0x03, 0xDC, 0x07, 0x44, 0x22, - 0x09, 0x38, 0x75, 0x01, 0x27, 0x67, 0xC0, 0x05, 0x03, 0xB6, 0xF8, 0x8D, 0x0C, 0x0A, 0x2F, 0xB0, - 0x25, 0x66, 0x7C, 0x73, 0xE8, 0x19, 0x8A, 0x67, 0x3A, 0x01, 0x83, 0x8A, 0xA6, 0xDF, 0x8D, 0x88, - 0xCC, 0x46, 0x0A, 0x7B, 0x9A, 0xC0, 0x82, 0x7C, 0xFC, 0x61, 0x88, 0x46, 0x24, 0x01, 0x21, 0x09, - 0x28, 0xD3, 0x63, 0xD6, 0x30, 0x61, 0x70, 0x58, 0xE6, 0x13, 0x42, 0x48, 0x2C, 0x2C, 0x99, 0x80, - 0x8C, 0xE1, 0xA0, 0x17, 0x0C, 0x34, 0xA0, 0x49, 0x85, 0xD1, 0x2D, 0x7F, 0xD4, 0xDC, 0x2E, 0x01, - 0x49, 0x02, 0x02, 0x94, 0x31, 0x58, 0x46, 0xCF, 0x50, 0x78, 0x35, 0xE9, 0xD5, 0xBC, 0x81, 0xD9, - 0xB9, 0x60, 0x40, 0xE7, 0x28, 0x22, 0xBF, 0x89, 0xAB, 0x73, 0x36, 0x8B, 0xC7, 0x1A, 0x04, 0x09, - 0x5E, 0xB5, 0x7E, 0x3C, 0x31, 0x97, 0xC3, 0x9E, 0x0F, 0x6A, 0x43, 0x41, 0xA7, 0x58, 0x2F, 0x2E, - 0x91, 0x10, 0xAB, 0x7F, 0xFD, 0xE9, 0x89, 0xE4, 0x68, 0x6C, 0x37, 0x9F, 0xDD, 0x8C, 0xBD, 0xBA, - 0x15, 0xFF, 0x7F, 0xD9, 0xB1, 0xD0, 0x81, 0x68, 0xC0, 0x00, 0x01, 0x8F, 0x70, 0x20, 0x32, 0xB0, - 0xAC, 0x90, 0x3C, 0xFF, 0xFB, 0x92, 0x64, 0x50, 0x0E, 0x04, 0x93, 0x34, 0x49, 0x0B, 0x9A, 0x4C, - 0x54, 0x2D, 0x01, 0xC9, 0xDD, 0x24, 0x23, 0x0E, 0x11, 0x2C, 0xD1, 0x2A, 0x6E, 0x69, 0x6F, 0x40, - 0xC2, 0xA2, 0xA6, 0xE8, 0x30, 0x8A, 0x9B, 0xF0, 0x34, 0x60, 0x50, 0xC1, 0xDB, 0x61, 0x68, 0xFB, - 0x72, 0xC5, 0x69, 0x36, 0x8D, 0x54, 0x33, 0xC9, 0xFB, 0xB8, 0xB8, 0x78, 0x6F, 0xF7, 0x2D, 0xE9, - 0x71, 0xF9, 0x52, 0x02, 0xC0, 0x52, 0x60, 0x4B, 0x9E, 0xA4, 0x3F, 0x9F, 0x34, 0xE2, 0xBC, 0x7A, - 0x90, 0x30, 0x0A, 0x31, 0x5A, 0x24, 0xD2, 0x83, 0x33, 0x5A, 0x0C, 0x8C, 0x8A, 0x49, 0x4E, 0x43, - 0x4B, 0x26, 0x0C, 0x0C, 0x42, 0x65, 0xA6, 0xF4, 0x13, 0x1F, 0x08, 0xB2, 0x61, 0x81, 0x98, 0xA0, - 0xEC, 0x30, 0x49, 0xEB, 0x50, 0xDD, 0xC5, 0x8B, 0x03, 0x07, 0x9C, 0x20, 0x09, 0x7A, 0x99, 0x82, - 0x22, 0x0C, 0x1A, 0xB5, 0x09, 0x01, 0x89, 0x4C, 0xCC, 0x64, 0x80, 0x23, 0xB2, 0xEB, 0x2D, 0x29, - 0x14, 0x62, 0xD5, 0x25, 0xAC, 0x72, 0xB0, 0x50, 0x07, 0x73, 0xAF, 0x49, 0x42, 0xD6, 0xDA, 0x17, - 0x36, 0xBD, 0x88, 0xE2, 0xA1, 0xFC, 0x70, 0x69, 0x07, 0x2C, 0xC4, 0xB0, 0x10, 0x7D, 0x42, 0x49, - 0x67, 0x07, 0x96, 0xCD, 0x7F, 0x72, 0xBF, 0xFC, 0x95, 0xB6, 0x4A, 0x40, 0xE2, 0x5F, 0xED, 0xCF, - 0x17, 0xE8, 0x7F, 0xD5, 0x9E, 0x7D, 0x11, 0x61, 0x12, 0x3F, 0xF6, 0xFC, 0x5F, 0x67, 0x6F, 0xA5, - 0x8C, 0x04, 0x00, 0x40, 0x21, 0xC0, 0x08, 0x62, 0xF3, 0x5B, 0xC4, 0x2F, 0xFA, 0x74, 0x78, 0x7F, - 0x22, 0xB7, 0xC5, 0x69, 0x74, 0x21, 0x7F, 0x62, 0x59, 0xB3, 0xAF, 0xFF, 0xA7, 0xFF, 0xFE, 0x6F, - 0xDA, 0x04, 0x85, 0x23, 0x7F, 0xFF, 0x0C, 0xA8, 0x97, 0x9D, 0x07, 0x79, 0x78, 0x27, 0x8B, 0x3B, - 0x6A, 0x00, 0x03, 0x09, 0x03, 0xF0, 0x60, 0x41, 0x79, 0xFA, 0xDA, 0xA6, 0x78, 0x0B, 0x99, 0x14, - 0x18, 0x62, 0x91, 0x01, 0xA0, 0xF7, 0xC7, 0x16, 0x1D, 0x98, 0x0C, 0x7E, 0x16, 0x0D, 0x9A, 0xCC, - 0x5E, 0x64, 0xC1, 0xD9, 0x84, 0x01, 0x46, 0x10, 0x54, 0x9E, 0x6C, 0x5E, 0x63, 0x61, 0xF8, 0x08, - 0x44, 0x65, 0x32, 0x59, 0xAC, 0x82, 0xC3, 0xC0, 0x25, 0xDC, 0x28, 0x71, 0xB4, 0xDB, 0x23, 0x22, - 0x24, 0x2B, 0x60, 0x90, 0xF4, 0x74, 0x28, 0xEC, 0x06, 0x55, 0x97, 0x2D, 0xC0, 0x4A, 0xA3, 0xC6, - 0xC1, 0x46, 0x20, 0x42, 0x67, 0xC5, 0x62, 0xEB, 0x0E, 0xD5, 0x35, 0x46, 0x9D, 0x89, 0x7F, 0x2E, - 0x61, 0xE2, 0x36, 0x46, 0xE4, 0x79, 0xE3, 0xAE, 0xE2, 0xBE, 0x72, 0x63, 0x39, 0x62, 0xC2, 0x80, - 0xAC, 0x7E, 0xBF, 0x1C, 0xD8, 0xFA, 0x91, 0xA3, 0x5A, 0xEE, 0x71, 0x7C, 0x6D, 0x7C, 0xE9, 0x45, - 0x8D, 0x7F, 0xF2, 0x76, 0xA6, 0xF3, 0x42, 0xA9, 0x03, 0x7C, 0x43, 0x8B, 0xAC, 0xA7, 0x52, 0xD4, - 0x7B, 0xFE, 0x37, 0x31, 0x77, 0xB0, 0x0E, 0x00, 0x00, 0x2A, 0x02, 0x1F, 0xD0, 0x2E, 0x06, 0x94, - 0x1B, 0x37, 0xA9, 0xE0, 0xB8, 0xFF, 0xFB, 0x92, 0x64, 0x52, 0x0F, 0x04, 0xAF, 0x34, 0x49, 0x93, - 0x99, 0x7C, 0x40, 0x2F, 0x43, 0x49, 0x73, 0x28, 0x22, 0x84, 0x11, 0x68, 0xCB, 0x26, 0x0E, 0x69, - 0xAF, 0x40, 0xC7, 0x8E, 0x27, 0xB4, 0x32, 0xA5, 0x72, 0x1D, 0xF1, 0xDE, 0x41, 0x0B, 0x23, 0xE0, - 0x08, 0xE8, 0x77, 0xFC, 0x2B, 0x58, 0x75, 0x56, 0xED, 0x62, 0x3F, 0xC9, 0x14, 0xDE, 0x68, 0xAF, - 0xF8, 0xD0, 0x20, 0x85, 0xEA, 0x3A, 0x01, 0x44, 0x37, 0x03, 0x3A, 0x28, 0x72, 0x00, 0x17, 0xCE, - 0xA1, 0x41, 0x33, 0xF8, 0xF4, 0x1A, 0x12, 0x30, 0x98, 0xFC, 0xCE, 0xE5, 0x83, 0x8E, 0x11, 0xC9, - 0x54, 0x44, 0x84, 0xD3, 0x3A, 0x37, 0x4C, 0x34, 0x5F, 0x30, 0x19, 0x28, 0xD0, 0x29, 0x03, 0x96, - 0x22, 0x84, 0x98, 0x29, 0xEA, 0x3A, 0xB8, 0xD0, 0xC1, 0x0E, 0x48, 0x97, 0x08, 0x08, 0x17, 0x66, - 0x86, 0xCC, 0x95, 0x82, 0x00, 0x8E, 0x53, 0xAD, 0xB0, 0x0B, 0x45, 0x2D, 0x98, 0x8B, 0x22, 0x1B, - 0xBA, 0xEF, 0x0B, 0x0F, 0x48, 0xF4, 0x8F, 0x5F, 0xED, 0x05, 0x01, 0x73, 0x95, 0x68, 0x0B, 0x01, - 0xA9, 0x95, 0x45, 0xBB, 0x91, 0x4A, 0x60, 0xD8, 0xBC, 0x48, 0x0C, 0x2E, 0x9A, 0xE8, 0xA8, 0x7A, - 0x17, 0x86, 0x29, 0x54, 0xF2, 0x6B, 0x16, 0x6F, 0xA3, 0xA2, 0x8E, 0x70, 0x4C, 0x47, 0x9F, 0xC6, - 0x39, 0x09, 0x64, 0xD0, 0xC4, 0x3C, 0x5D, 0x42, 0x6A, 0x7A, 0xA0, 0x68, 0x3C, 0x7B, 0xFD, 0x6E, - 0x48, 0xD9, 0xA4, 0xB6, 0xC2, 0xC1, 0xC0, 0x90, 0x22, 0x86, 0x39, 0x45, 0xC0, 0x3E, 0x25, 0x04, - 0xE3, 0x67, 0x0B, 0xEA, 0x12, 0x7D, 0x94, 0x44, 0x57, 0xDF, 0xEF, 0x37, 0x47, 0x92, 0x0C, 0xAA, - 0x8C, 0x06, 0x22, 0x03, 0xC9, 0x9A, 0x03, 0x5F, 0xD3, 0xBB, 0x77, 0xF1, 0xBB, 0xFF, 0xEB, 0x54, - 0x73, 0x13, 0x0B, 0x97, 0x6A, 0x84, 0x24, 0xEA, 0x00, 0x03, 0x06, 0xE4, 0xD2, 0x44, 0x20, 0x11, - 0x85, 0xE4, 0x49, 0x9E, 0xA0, 0x90, 0x91, 0x32, 0x60, 0x70, 0x7E, 0x65, 0x35, 0x6E, 0x62, 0x11, - 0x26, 0x60, 0xB0, 0x92, 0x22, 0x1E, 0x4C, 0x14, 0x47, 0x0C, 0x31, 0x2D, 0x4C, 0x51, 0x0C, 0x0C, - 0xB1, 0x02, 0x0D, 0x1B, 0x43, 0xCC, 0x46, 0x09, 0x0C, 0x5B, 0x19, 0x0C, 0x18, 0x02, 0x8C, 0xC1, - 0x08, 0x4C, 0x15, 0x02, 0x00, 0xC0, 0x10, 0x8D, 0x49, 0xDB, 0x16, 0x9D, 0x89, 0xF0, 0x30, 0x00, - 0xA4, 0xC5, 0x85, 0xE2, 0xCE, 0x45, 0x90, 0x88, 0x03, 0xAC, 0x93, 0x50, 0x05, 0x8C, 0x2A, 0x31, - 0xC4, 0x62, 0xC9, 0xD0, 0xC9, 0x38, 0x93, 0x5C, 0x40, 0x0A, 0x0F, 0xCA, 0x0A, 0x08, 0x62, 0xF2, - 0xB9, 0x23, 0x30, 0x4C, 0x28, 0x44, 0xEB, 0xC2, 0x26, 0x95, 0xA7, 0x67, 0xA8, 0xA0, 0xF0, 0x27, - 0x34, 0x31, 0x1D, 0xE4, 0x52, 0xF8, 0x49, 0x7F, 0xFE, 0x19, 0xB0, 0xC4, 0xB0, 0xC1, 0xFF, 0xBC, - 0x15, 0x61, 0xB8, 0x8A, 0x6D, 0xBA, 0x08, 0x8C, 0xC9, 0x64, 0x19, 0x19, 0xFF, 0xD2, 0xC6, 0xE6, - 0x21, 0x41, 0xD5, 0xD3, 0x08, 0x80, 0x01, 0xFF, 0xFB, 0x92, 0x64, 0x4F, 0x8E, 0x04, 0xDF, 0x33, - 0x49, 0x13, 0xBA, 0x5C, 0x40, 0x2D, 0xA8, 0xF9, 0xFA, 0x08, 0x23, 0x9E, 0x91, 0x48, 0xCB, 0x24, - 0x2E, 0x65, 0x71, 0x10, 0xC3, 0x9F, 0x28, 0x28, 0x80, 0x8E, 0x7A, 0x05, 0x24, 0x28, 0x00, 0x8A, - 0xF5, 0x95, 0xA4, 0x7F, 0xD0, 0xC2, 0xDD, 0x95, 0x53, 0xC8, 0x00, 0x59, 0x3A, 0xF7, 0xFD, 0x7F, - 0xD2, 0x2D, 0xCD, 0xFF, 0xF3, 0x07, 0xEF, 0xBC, 0x1F, 0xFF, 0xFF, 0xCA, 0xED, 0xAC, 0x85, 0x22, - 0xEC, 0xA1, 0x7F, 0x28, 0xD8, 0x32, 0x49, 0x25, 0xA6, 0x04, 0x1D, 0x19, 0x8A, 0xB8, 0x66, 0xD1, - 0x81, 0x8D, 0xC4, 0xA6, 0x42, 0x44, 0x0D, 0x72, 0x40, 0x42, 0xB0, 0x51, 0x4C, 0xCC, 0x05, 0xD3, - 0x5A, 0xD4, 0x48, 0x51, 0x46, 0x41, 0x18, 0x1C, 0x58, 0x14, 0x7B, 0x4A, 0x30, 0x92, 0x70, 0xC3, - 0x43, 0x35, 0x05, 0x30, 0x59, 0x92, 0xB4, 0x70, 0x52, 0x90, 0x7F, 0x46, 0x08, 0x00, 0x22, 0xC9, - 0x06, 0x38, 0x81, 0x92, 0x5E, 0x21, 0x55, 0x26, 0x50, 0xC1, 0xAF, 0x02, 0xB2, 0x59, 0x48, 0x0B, - 0x24, 0x74, 0xCF, 0x0D, 0x45, 0x83, 0x8E, 0x40, 0xC0, 0x74, 0x31, 0x2A, 0x65, 0xB4, 0x59, 0xF8, - 0xE3, 0x51, 0x15, 0xAC, 0x5A, 0xC5, 0x9D, 0x6A, 0x1C, 0x69, 0x8F, 0xAF, 0x81, 0xDE, 0x33, 0x53, - 0x22, 0x08, 0x04, 0x22, 0x07, 0x5A, 0xFF, 0xFC, 0x96, 0x78, 0x8E, 0x3D, 0x88, 0x1B, 0xFC, 0xC4, - 0x9C, 0xE4, 0x41, 0x18, 0x4A, 0x3B, 0x16, 0x28, 0x1D, 0xB3, 0x85, 0x22, 0x77, 0x7F, 0xD1, 0xAB, - 0x00, 0x00, 0x42, 0x0A, 0x68, 0x58, 0x1C, 0x0F, 0x27, 0x95, 0x1F, 0xF1, 0x7F, 0xFF, 0x05, 0xC3, - 0xD4, 0xD3, 0x29, 0x0B, 0x88, 0xC3, 0x2D, 0x33, 0xAD, 0x11, 0xCC, 0xDB, 0xFF, 0xF6, 0xE6, 0x2F, - 0xCF, 0x93, 0xFF, 0xDE, 0x45, 0xFF, 0xFF, 0xF9, 0x68, 0x3D, 0xB5, 0x92, 0x90, 0x3B, 0xEB, 0xE9, - 0x5D, 0x84, 0x00, 0x00, 0x00, 0x50, 0x32, 0x58, 0x22, 0x03, 0x19, 0x08, 0x5C, 0x45, 0x20, 0xBC, - 0x87, 0x00, 0x1E, 0x16, 0x01, 0x00, 0x47, 0x10, 0x97, 0xB8, 0xD0, 0x1E, 0x1C, 0x14, 0x17, 0x18, - 0x44, 0x90, 0xC6, 0xE9, 0x1C, 0x00, 0x0E, 0x34, 0xF2, 0x8B, 0x30, 0x87, 0xA4, 0xE1, 0xF6, 0x22, - 0x4C, 0x4A, 0xC2, 0xA0, 0xE0, 0x97, 0xA6, 0x60, 0xC6, 0x86, 0x84, 0xE5, 0x99, 0xBD, 0x58, 0xF1, - 0x5A, 0x7E, 0x1F, 0x71, 0xA2, 0x31, 0x95, 0xFB, 0x43, 0x94, 0xE9, 0xDC, 0x79, 0x22, 0xBF, 0x95, - 0x22, 0xD2, 0x82, 0xE3, 0xC8, 0x49, 0x3C, 0xFE, 0x2B, 0x2C, 0xE7, 0x8D, 0x7F, 0x5E, 0xA5, 0xCE, - 0x64, 0x3F, 0x0B, 0x8C, 0xFF, 0xE7, 0xC7, 0x48, 0x3A, 0x74, 0x75, 0x4B, 0x7A, 0xED, 0x46, 0x63, - 0xFE, 0x9E, 0xBD, 0x7D, 0x1C, 0x82, 0x81, 0x00, 0x09, 0x08, 0x80, 0x84, 0x16, 0x85, 0x02, 0xC6, - 0xC5, 0x4E, 0x29, 0xFA, 0xDE, 0xF6, 0x40, 0xA3, 0x13, 0x0F, 0x9E, 0xAB, 0x72, 0xFF, 0x77, 0xFC, - 0xCE, 0x34, 0x36, 0x20, 0x2E, 0xDF, 0xFE, 0x93, 0xB0, 0xFF, 0xFB, 0x92, 0x64, 0x4C, 0x04, 0x03, - 0xA5, 0x32, 0xCE, 0x53, 0x4F, 0x3C, 0x44, 0x32, 0xC0, 0x4A, 0x1D, 0x05, 0x82, 0x00, 0x92, 0x44, - 0xCB, 0x28, 0x6E, 0x65, 0x6F, 0x40, 0xCB, 0x8A, 0xA6, 0x28, 0x30, 0x1D, 0x40, 0x21, 0x3A, 0xD0, - 0x70, 0x1F, 0x48, 0x38, 0x81, 0x45, 0x0B, 0x0B, 0x84, 0x1F, 0x88, 0xE2, 0xA0, 0x00, 0x00, 0x9A, - 0xD6, 0x8C, 0xB2, 0x23, 0x47, 0xC6, 0x0C, 0xA4, 0x06, 0x10, 0x83, 0x0C, 0x42, 0x72, 0x34, 0x2E, - 0x24, 0xC8, 0x62, 0x93, 0x4F, 0x92, 0x0C, 0x3C, 0x15, 0x35, 0x68, 0x88, 0xC1, 0xE5, 0xD0, 0x62, - 0x28, 0xCC, 0x81, 0xF3, 0x64, 0xB8, 0x8C, 0x10, 0x3A, 0x31, 0x60, 0xEC, 0xF2, 0x78, 0x28, 0xE8, - 0xF1, 0x2C, 0xB0, 0x45, 0x2C, 0x32, 0xA9, 0x91, 0x60, 0x61, 0xE4, 0x24, 0xAC, 0x36, 0xD4, 0x01, - 0x2B, 0x24, 0x70, 0x10, 0x10, 0x45, 0x9C, 0xD4, 0xD4, 0xC0, 0x88, 0x64, 0xB4, 0x41, 0xE2, 0xFA, - 0xB0, 0x45, 0x1F, 0x62, 0xA5, 0x81, 0xD0, 0x7A, 0x4A, 0xC4, 0x48, 0x45, 0x4E, 0x78, 0xBD, 0x64, - 0xEE, 0xCD, 0x94, 0xF9, 0xB4, 0x00, 0x9F, 0xCA, 0x14, 0x3A, 0xD9, 0x8F, 0x8F, 0xCA, 0x67, 0x48, - 0x42, 0x5E, 0x7F, 0xCC, 0x48, 0x7B, 0xDE, 0x54, 0xDA, 0x7B, 0xA4, 0xE8, 0xF2, 0x35, 0xFF, 0xE9, - 0xAC, 0x5D, 0x67, 0xC3, 0x83, 0x5C, 0x95, 0xDD, 0x51, 0x5B, 0xFF, 0xDB, 0xFF, 0xA6, 0xB0, 0x02, - 0x10, 0x00, 0x05, 0x03, 0x40, 0x28, 0x57, 0xA0, 0x8B, 0x47, 0xEB, 0x2A, 0x4D, 0x21, 0x43, 0x0A, - 0x9E, 0xE5, 0x34, 0xBA, 0x2E, 0xAF, 0x22, 0xC0, 0xF8, 0x2A, 0xF0, 0x30, 0xF2, 0xEE, 0x54, 0x35, - 0xEA, 0x7D, 0x2A, 0x7E, 0xBC, 0xC6, 0x39, 0xDF, 0xE8, 0x2B, 0x2E, 0x71, 0x82, 0xCA, 0x12, 0x81, - 0xB2, 0x4A, 0x00, 0x03, 0x08, 0x3A, 0x1E, 0x30, 0x28, 0x7C, 0xC1, 0xE2, 0x70, 0x55, 0x80, 0xC8, - 0x22, 0x13, 0x20, 0x9B, 0x8D, 0x69, 0xAE, 0x36, 0x48, 0x68, 0xCB, 0x41, 0x03, 0x03, 0x13, 0xCC, - 0xFC, 0x2A, 0x2F, 0x51, 0x82, 0x88, 0x86, 0x8A, 0x48, 0x09, 0xAF, 0x0C, 0xBC, 0x20, 0x31, 0x18, - 0xB4, 0xFA, 0xA8, 0x0A, 0x83, 0xE6, 0x9B, 0x80, 0x83, 0x4F, 0x8B, 0x94, 0xA9, 0xDB, 0x15, 0xA0, - 0x5A, 0x35, 0x2D, 0x6E, 0x82, 0x87, 0x2A, 0xA4, 0x91, 0x9C, 0x02, 0x97, 0x75, 0x9D, 0xA4, 0x7A, - 0x43, 0xE5, 0x6D, 0x5B, 0xB2, 0x10, 0x51, 0x29, 0xDA, 0xF6, 0xA5, 0xA9, 0x34, 0x90, 0x6B, 0xA2, - 0x33, 0x49, 0xD8, 0x83, 0x34, 0x83, 0x52, 0x1E, 0x14, 0x2B, 0x6F, 0x05, 0xED, 0x60, 0x65, 0xF4, - 0x14, 0x14, 0xD7, 0xFF, 0xEB, 0xB2, 0xE6, 0x9B, 0xFB, 0x0D, 0x35, 0x90, 0xA4, 0x0B, 0x95, 0x12, - 0x6F, 0x2A, 0x29, 0xCD, 0x4C, 0x2D, 0x1F, 0x83, 0xD5, 0xFE, 0x56, 0xC2, 0x3A, 0x69, 0xEB, 0x7A, - 0x92, 0x01, 0x00, 0x89, 0x2D, 0x83, 0x32, 0x13, 0x0F, 0x75, 0xC8, 0x41, 0x74, 0x5F, 0xD5, 0x9F, - 0xBA, 0x5B, 0x4D, 0xFC, 0xDA, 0xA5, 0x7E, 0xBF, 0x7F, 0xFB, 0x7D, 0xFF, 0xFB, 0x92, 0x64, 0x54, - 0x8E, 0x04, 0x68, 0x33, 0x49, 0x93, 0x99, 0x4B, 0xD0, 0x31, 0x08, 0x6A, 0x4C, 0x07, 0x02, 0x01, - 0x92, 0x18, 0xCD, 0x26, 0x4E, 0x69, 0x8F, 0x50, 0xCC, 0x9A, 0xA7, 0x68, 0x20, 0x8E, 0x3B, 0x7F, - 0x95, 0x69, 0xD1, 0x7F, 0xDA, 0x88, 0xED, 0xAD, 0xFF, 0xFC, 0xCC, 0x11, 0x91, 0xAE, 0xA5, 0x65, - 0x28, 0x99, 0x1B, 0x2A, 0x08, 0x24, 0xCA, 0xAC, 0x62, 0x22, 0x39, 0xA2, 0x4C, 0x66, 0xA2, 0x1D, - 0x99, 0x04, 0x00, 0x60, 0x52, 0x61, 0xBA, 0xF3, 0x46, 0x68, 0x20, 0x97, 0xEC, 0xCA, 0x22, 0x30, - 0x8B, 0x71, 0x9A, 0x80, 0x66, 0x41, 0x49, 0x1B, 0xC9, 0x02, 0x76, 0xF7, 0x19, 0x86, 0x49, 0x06, - 0x8C, 0x03, 0x17, 0xA0, 0x4F, 0x7B, 0x16, 0x10, 0x0A, 0x32, 0x44, 0x06, 0xD4, 0xB1, 0x54, 0x53, - 0x1D, 0x08, 0x89, 0x70, 0xB6, 0x8D, 0x38, 0x5F, 0xD7, 0x1D, 0x1B, 0x81, 0x80, 0xDA, 0xAB, 0x27, - 0x15, 0x16, 0x9C, 0xE8, 0xBC, 0xD9, 0x9E, 0x82, 0xE3, 0x4B, 0xE9, 0x21, 0xB7, 0x25, 0x90, 0xBA, - 0xA1, 0x62, 0xE2, 0xDD, 0x5D, 0x15, 0x73, 0x07, 0x57, 0x0D, 0x38, 0x50, 0x8F, 0x87, 0x00, 0x29, - 0x13, 0x14, 0xC9, 0x99, 0x9D, 0x6A, 0xD0, 0xEF, 0xAD, 0xDF, 0xB5, 0xF5, 0xBA, 0x41, 0x11, 0xE3, - 0x6E, 0xD3, 0xD2, 0x17, 0xFE, 0x74, 0x82, 0xFC, 0xB8, 0xDC, 0x27, 0xBF, 0xC8, 0x61, 0x10, 0x99, - 0x73, 0x6E, 0x14, 0x40, 0x9A, 0xA0, 0xC1, 0x00, 0x01, 0x46, 0x40, 0x14, 0x04, 0x80, 0x54, 0x1C, - 0x35, 0x26, 0xFA, 0x6A, 0x53, 0x52, 0x37, 0x97, 0x3C, 0x3D, 0xFC, 0x9F, 0xFF, 0xCE, 0x65, 0xE4, - 0x66, 0x8F, 0xA2, 0x14, 0xBF, 0xFE, 0x52, 0xAC, 0x66, 0xE1, 0x64, 0xA1, 0xFD, 0x97, 0x11, 0x9F, - 0x54, 0xA1, 0x2A, 0x9C, 0x8B, 0x8E, 0x75, 0xB9, 0x00, 0x02, 0x08, 0x65, 0x0E, 0x42, 0x81, 0x23, - 0x37, 0x4B, 0x4C, 0x74, 0x49, 0x31, 0xA0, 0x20, 0xAC, 0xA4, 0x61, 0xFC, 0xC9, 0x87, 0xCD, 0xE4, - 0xC0, 0x13, 0x07, 0x01, 0xCD, 0x34, 0x4F, 0x30, 0xF8, 0xB8, 0x80, 0x4A, 0x6B, 0x92, 0x88, 0x31, - 0x88, 0x61, 0x70, 0x79, 0x86, 0x48, 0xC7, 0x19, 0x66, 0x91, 0x0A, 0x02, 0x2A, 0xB9, 0xA9, 0x40, - 0x34, 0xB5, 0x46, 0x45, 0x1A, 0x43, 0x0A, 0x05, 0x20, 0x6B, 0x83, 0xA2, 0x31, 0x15, 0x5D, 0x2C, - 0x00, 0x30, 0x99, 0x30, 0xA1, 0x10, 0x24, 0xC5, 0x24, 0xD3, 0xF7, 0x9B, 0x03, 0xB7, 0x84, 0x75, - 0xDA, 0x4D, 0x39, 0x63, 0x1B, 0x17, 0x85, 0xF9, 0x81, 0x14, 0xFF, 0x85, 0x78, 0x55, 0x79, 0x0E, - 0x19, 0x02, 0x62, 0x87, 0x8C, 0xFE, 0xB9, 0xA9, 0xA9, 0xBD, 0xAC, 0xA7, 0x49, 0xED, 0x02, 0xF3, - 0x6D, 0x86, 0xF0, 0x44, 0xA2, 0x1F, 0xC7, 0x71, 0x1E, 0x5C, 0x7C, 0xE9, 0x2F, 0xF2, 0xE2, 0x97, - 0x22, 0x55, 0x72, 0xE0, 0x11, 0x70, 0x87, 0x00, 0x00, 0x00, 0x87, 0x80, 0x24, 0x1C, 0xC6, 0x47, - 0x5A, 0x65, 0xFB, 0x57, 0x21, 0x23, 0x17, 0x06, 0x17, 0x79, 0xA8, 0xC3, 0x81, 0xFF, 0xFB, 0x92, - 0x64, 0x52, 0x8F, 0x44, 0x6C, 0x33, 0x4A, 0x13, 0x99, 0x5B, 0xD4, 0x30, 0xC1, 0xE9, 0x7A, 0x05, - 0x22, 0x20, 0x11, 0x58, 0xD3, 0x24, 0x0E, 0x65, 0xF1, 0x00, 0xBF, 0x0D, 0x26, 0xB4, 0x10, 0x09, - 0x08, 0x84, 0xB2, 0x27, 0x7F, 0x63, 0x4F, 0x4E, 0xB2, 0x1A, 0xBF, 0x77, 0xF5, 0x3E, 0x58, 0xF7, - 0x7A, 0xCF, 0x0B, 0x08, 0x41, 0xA8, 0x04, 0x5A, 0x65, 0x43, 0x23, 0xEE, 0xC1, 0x8C, 0x42, 0xA6, - 0xF7, 0x3B, 0x98, 0xAC, 0x46, 0x67, 0x80, 0x40, 0xF1, 0x08, 0xEE, 0x40, 0x73, 0x4D, 0x83, 0x4D, - 0x86, 0x7D, 0x06, 0x84, 0x0D, 0x27, 0x08, 0x05, 0x1F, 0x4C, 0x02, 0x4F, 0x31, 0xB1, 0xF4, 0x12, - 0xDF, 0x1A, 0x17, 0x18, 0xBC, 0xBA, 0x09, 0x0E, 0x04, 0x33, 0x56, 0x71, 0x00, 0x3C, 0xD3, 0x48, - 0x17, 0xDB, 0xAA, 0xFC, 0x85, 0x49, 0x1A, 0x71, 0x00, 0x89, 0x46, 0x14, 0x98, 0x90, 0x27, 0xCE, - 0x80, 0xC5, 0x4D, 0x0F, 0x4A, 0x03, 0x64, 0x00, 0x6F, 0x80, 0x4A, 0x47, 0x1F, 0x51, 0x00, 0x54, - 0xF7, 0xE1, 0x84, 0xB1, 0x11, 0x0B, 0x1F, 0x41, 0xB0, 0x61, 0x93, 0x10, 0xF7, 0x6C, 0x8A, 0xF6, - 0x69, 0x6E, 0x86, 0x96, 0x47, 0x8C, 0x46, 0x27, 0x7F, 0xFF, 0xFF, 0xF5, 0x8D, 0x5C, 0xEA, 0x2B, - 0x7C, 0x0D, 0xF9, 0x59, 0xAA, 0x88, 0x9A, 0x8A, 0xF5, 0xD1, 0x74, 0x69, 0xDE, 0x8E, 0xC6, 0x9A, - 0xDD, 0x0F, 0x9F, 0x0E, 0x1A, 0x2E, 0x2E, 0x00, 0x09, 0x83, 0x80, 0x0D, 0xE6, 0xA8, 0x18, 0x19, - 0x43, 0x35, 0xC4, 0xB9, 0x72, 0x90, 0x18, 0x64, 0x62, 0xED, 0x56, 0x52, 0xB6, 0xF6, 0x46, 0x10, - 0x9E, 0xA0, 0x44, 0x97, 0xCE, 0x87, 0x99, 0xAA, 0xCF, 0xBB, 0xFA, 0xD0, 0x5A, 0x10, 0x22, 0xC3, - 0x83, 0x8B, 0x05, 0x14, 0x35, 0x01, 0x30, 0x4E, 0xF1, 0xA0, 0x90, 0xD4, 0x82, 0xA0, 0xC2, 0x11, - 0x28, 0x60, 0x13, 0x31, 0x64, 0xC4, 0x32, 0x06, 0x72, 0x32, 0x1C, 0x3C, 0x32, 0x28, 0xBC, 0x0B, - 0x83, 0x26, 0x23, 0x22, 0xA6, 0x9E, 0xF6, 0x67, 0x23, 0xE6, 0xE4, 0xAC, 0x79, 0x1A, 0x42, 0xA2, - 0x01, 0xC1, 0x00, 0x50, 0xF1, 0xAD, 0x80, 0x81, 0x12, 0xFF, 0x86, 0x1E, 0x93, 0x73, 0x95, 0x83, - 0x96, 0x89, 0x6C, 0x88, 0x01, 0x49, 0x83, 0x18, 0x61, 0x80, 0x91, 0x03, 0x87, 0x1C, 0xC8, 0xE1, - 0x87, 0x01, 0x84, 0x05, 0xBD, 0xC5, 0x50, 0x23, 0x12, 0x05, 0x1C, 0x07, 0xB8, 0x91, 0xE5, 0xB5, - 0x87, 0x24, 0x43, 0x28, 0xD3, 0x53, 0x2A, 0x84, 0x2C, 0x4C, 0x55, 0x94, 0x7C, 0xA8, 0x0A, 0xDA, - 0x6F, 0xC8, 0x6F, 0xBD, 0x51, 0xA1, 0x29, 0xFA, 0xFF, 0xFF, 0xFF, 0xE6, 0x9F, 0xE2, 0x68, 0x10, - 0x37, 0xB8, 0x31, 0x34, 0x87, 0xB4, 0x29, 0x4D, 0xB6, 0x23, 0x7E, 0x16, 0xF0, 0xE3, 0x3E, 0xB5, - 0x32, 0xAC, 0x62, 0x9A, 0x7B, 0xFE, 0x94, 0x7B, 0x15, 0xC6, 0x80, 0x70, 0x00, 0x00, 0x08, 0x2C, - 0x05, 0x0A, 0xFF, 0x01, 0x56, 0x45, 0xB5, 0x61, 0x14, 0xC5, 0x23, 0x7F, 0x17, 0x34, 0x5F, 0xFF, - 0xFB, 0x92, 0x64, 0x55, 0x0F, 0x44, 0xA9, 0x34, 0xC8, 0x8B, 0xBB, 0x7A, 0xE4, 0x31, 0x43, 0x39, - 0x9A, 0x00, 0xA6, 0x36, 0x0F, 0xC8, 0xCF, 0x26, 0x0E, 0x69, 0x2B, 0xD0, 0xC0, 0x8B, 0xE5, 0xA8, - 0x23, 0x0D, 0xC8, 0x29, 0xCD, 0x3B, 0x59, 0x3C, 0xEE, 0x76, 0xE3, 0x2C, 0x26, 0x15, 0x75, 0x53, - 0xDF, 0xAD, 0x3F, 0x76, 0xB6, 0xFF, 0xD1, 0x69, 0xB0, 0x51, 0x49, 0x34, 0x59, 0x25, 0x42, 0xF0, - 0xD2, 0xD1, 0x2C, 0x03, 0x0C, 0x5A, 0x58, 0x02, 0x01, 0x06, 0x00, 0x85, 0xAF, 0x36, 0x1C, 0xC4, - 0xC8, 0x45, 0x03, 0x20, 0x84, 0xD8, 0xC9, 0xAA, 0x4B, 0xC6, 0x70, 0x29, 0xAC, 0x84, 0x67, 0xE4, - 0x1D, 0x52, 0x06, 0x31, 0x41, 0x99, 0x8E, 0x08, 0x10, 0x42, 0x94, 0x12, 0x80, 0x68, 0x32, 0x4C, - 0x00, 0x9B, 0x2B, 0xB5, 0xC8, 0xEF, 0x22, 0x95, 0x65, 0xE4, 0xDD, 0xC1, 0x4F, 0x60, 0x59, 0x21, - 0x81, 0x1C, 0x89, 0x73, 0xAB, 0x28, 0x40, 0x05, 0x1A, 0xB2, 0x84, 0x34, 0x2A, 0x2D, 0x29, 0xD3, - 0xAF, 0x39, 0x2C, 0x51, 0xF0, 0x20, 0xA6, 0x9F, 0xEA, 0x3E, 0xF9, 0x11, 0x3F, 0x3D, 0x50, 0x04, - 0x5A, 0x60, 0x7B, 0xBF, 0x49, 0x02, 0x4C, 0x7F, 0xFF, 0xFF, 0x53, 0x47, 0x9A, 0x8E, 0x36, 0xA9, - 0x19, 0xA2, 0x57, 0xB7, 0xB9, 0x3C, 0x6B, 0x08, 0xCB, 0x95, 0x1B, 0x0F, 0xFF, 0x40, 0x06, 0x00, - 0x00, 0x02, 0x30, 0xE4, 0x6E, 0x77, 0xB8, 0x6F, 0xDD, 0x8A, 0x84, 0x42, 0x66, 0x65, 0xC8, 0xC2, - 0xC1, 0x65, 0xE5, 0x41, 0xE5, 0x2A, 0xDC, 0x84, 0x15, 0x07, 0xC3, 0xE1, 0xEF, 0xBB, 0xF7, 0xFD, - 0xDD, 0x47, 0xBF, 0xE6, 0x56, 0x02, 0x1E, 0x20, 0x48, 0x65, 0x5A, 0x3B, 0xBE, 0x7D, 0x01, 0xB3, - 0x89, 0x0C, 0x0A, 0xC2, 0xF6, 0x63, 0x50, 0x09, 0x82, 0x02, 0x21, 0x70, 0x49, 0xB1, 0x25, 0xE6, - 0x51, 0x31, 0x99, 0x6C, 0xCE, 0x60, 0x32, 0x29, 0xB4, 0x87, 0x26, 0x01, 0x2A, 0x18, 0xF4, 0xD0, - 0x6A, 0x34, 0x79, 0xED, 0xDA, 0x06, 0x18, 0x63, 0x70, 0x1C, 0x79, 0x07, 0xD5, 0x61, 0x7D, 0x82, - 0x81, 0x4B, 0x9A, 0x74, 0x82, 0x43, 0xCA, 0xD0, 0x54, 0x00, 0xFA, 0x60, 0xA3, 0x64, 0x80, 0x48, - 0x40, 0xBC, 0xD6, 0x0B, 0x6A, 0xB0, 0xE8, 0x88, 0xE6, 0x01, 0x84, 0x86, 0x33, 0xA8, 0xC8, 0x14, - 0xE2, 0x82, 0xCA, 0x8E, 0x34, 0xF5, 0x2F, 0x77, 0x19, 0x69, 0x6E, 0xD9, 0x75, 0xB8, 0x09, 0x9B, - 0xCB, 0xEF, 0xE5, 0x01, 0xD3, 0x02, 0x25, 0xFF, 0xE9, 0x12, 0xD5, 0xFD, 0xFD, 0x25, 0x76, 0x39, - 0x02, 0x4E, 0xA5, 0xA0, 0xC1, 0x2F, 0x44, 0xBB, 0x48, 0xE6, 0x9A, 0x06, 0xF8, 0xA5, 0xC1, 0xAD, - 0x37, 0xFD, 0x6A, 0xFD, 0x57, 0x75, 0x7F, 0x9A, 0x63, 0x08, 0x01, 0xA8, 0x20, 0x00, 0x8B, 0x7F, - 0x04, 0x85, 0x2D, 0x06, 0x79, 0x16, 0xFD, 0x31, 0x52, 0x02, 0xE0, 0x64, 0x22, 0x50, 0xFB, 0x9A, - 0x18, 0xDE, 0x4E, 0x2B, 0xC6, 0x8B, 0xEF, 0xF9, 0x8A, 0x97, 0x74, 0x7D, 0xFE, 0x8F, 0x3C, 0x60, - 0xD2, 0xFF, 0xFB, 0x92, 0x64, 0x59, 0x8E, 0x04, 0x55, 0x34, 0x49, 0x0B, 0x9A, 0x4B, 0x64, 0x32, - 0x21, 0x59, 0xBD, 0x18, 0x22, 0x00, 0x10, 0x38, 0xD3, 0x26, 0x4D, 0xE1, 0x2F, 0x40, 0xCE, 0x8D, - 0xA5, 0xCC, 0x14, 0x8C, 0x38, 0x29, 0xCC, 0x90, 0x17, 0x75, 0x66, 0x59, 0x73, 0xF4, 0x28, 0x30, - 0x86, 0x5C, 0x23, 0x10, 0x2C, 0x31, 0x98, 0xF0, 0x7F, 0x28, 0x20, 0x44, 0x0B, 0x10, 0x6D, 0x9B, - 0x83, 0x4E, 0x66, 0x8A, 0xE4, 0x0A, 0x39, 0x33, 0xF8, 0x04, 0xB3, 0x33, 0xE7, 0xE3, 0x35, 0x0A, - 0x31, 0x04, 0x81, 0x01, 0x69, 0x28, 0x19, 0xC8, 0xEA, 0x2E, 0x87, 0x80, 0x18, 0x85, 0x60, 0x82, - 0x1E, 0x22, 0xBA, 0x89, 0x8E, 0x82, 0x42, 0xA1, 0x83, 0x03, 0x4C, 0x89, 0x1B, 0x44, 0x4C, 0xC0, - 0x54, 0x59, 0x2A, 0xF7, 0x61, 0x04, 0x24, 0x94, 0x33, 0xD4, 0x02, 0x2C, 0x0C, 0xFB, 0x0A, 0x62, - 0x0A, 0xA7, 0x55, 0x09, 0xCA, 0x5D, 0x03, 0x71, 0x7E, 0x36, 0xD5, 0x73, 0xF7, 0x30, 0x67, 0x09, - 0x04, 0x9F, 0xFA, 0xD0, 0x71, 0x8A, 0x8F, 0xF4, 0x6D, 0xFD, 0x2C, 0x43, 0xCF, 0x41, 0x33, 0x88, - 0x18, 0xC8, 0xF6, 0xDD, 0x93, 0xF6, 0x88, 0x99, 0x07, 0x6F, 0x7F, 0xDD, 0x5B, 0x85, 0x52, 0xAE, - 0x90, 0x00, 0x21, 0xC0, 0x0E, 0x4F, 0x51, 0x58, 0x1C, 0x0F, 0x89, 0xC8, 0x84, 0x88, 0x1C, 0x93, - 0x08, 0xE4, 0xC7, 0x24, 0x8A, 0x45, 0xD3, 0x53, 0x35, 0x5B, 0xB0, 0xC8, 0x80, 0xB4, 0x11, 0x59, - 0xBE, 0x4E, 0x37, 0x83, 0xF5, 0xF6, 0x0E, 0x88, 0xDF, 0xB9, 0x2C, 0xED, 0x55, 0x14, 0x69, 0xCB, - 0xA7, 0xF3, 0xA0, 0x65, 0x2A, 0x01, 0x1F, 0x56, 0xB4, 0x01, 0x20, 0x36, 0x4B, 0xD3, 0xC8, 0x17, - 0x25, 0x08, 0x3A, 0x28, 0x13, 0x5B, 0x11, 0x11, 0x16, 0x9B, 0x44, 0x08, 0x58, 0x50, 0xA8, 0xBE, - 0x38, 0x5A, 0x63, 0x95, 0x46, 0x6E, 0xBA, 0x61, 0xDC, 0xA0, 0xD3, 0x70, 0x48, 0xF9, 0xA5, 0xA3, - 0x80, 0x85, 0x0B, 0x52, 0x06, 0x05, 0x2C, 0x70, 0x4F, 0x3C, 0x80, 0xBC, 0x09, 0xCA, 0x97, 0x6D, - 0xA8, 0x5C, 0x04, 0xBA, 0x53, 0x7A, 0xB0, 0xF0, 0xA8, 0xAB, 0x61, 0xAB, 0x82, 0x01, 0x4C, 0x35, - 0x85, 0x6A, 0x0A, 0x04, 0x95, 0xCC, 0x09, 0xE6, 0x86, 0x91, 0xB3, 0x56, 0xD5, 0x44, 0x8F, 0x2B, - 0x13, 0x4A, 0x5C, 0xE4, 0x01, 0xF1, 0xEC, 0x87, 0x1F, 0x34, 0x5A, 0xD1, 0xB9, 0xF5, 0xFE, 0xE4, - 0xE0, 0x8F, 0xFF, 0xEA, 0x13, 0x5D, 0x9F, 0x83, 0xC6, 0xE4, 0xFA, 0x84, 0x88, 0xD6, 0x77, 0x4B, - 0xD1, 0xB3, 0x43, 0xC6, 0xFF, 0xEC, 0x65, 0x1C, 0xCA, 0x00, 0x00, 0x40, 0x04, 0xDD, 0xE0, 0x4E, - 0x26, 0xF0, 0x40, 0x74, 0x64, 0x34, 0x35, 0xB3, 0x65, 0xA4, 0x23, 0x12, 0x56, 0x59, 0xA2, 0x1C, - 0x4C, 0x96, 0xD6, 0xE0, 0xD1, 0xF0, 0x9A, 0x0B, 0x63, 0xAA, 0xA1, 0x5F, 0x76, 0xBE, 0x8F, 0x40, - 0x9F, 0x47, 0xEF, 0x32, 0x2B, 0xA4, 0xA1, 0xB0, 0xB3, 0x4E, 0x87, 0x82, 0x0B, 0xAD, 0xE0, 0x8C, - 0x38, 0x69, 0x7F, 0xFF, 0xFB, 0x92, 0x64, 0x5F, 0x0E, 0x84, 0x1D, 0x33, 0xC9, 0x0B, 0x79, 0x5C, - 0x44, 0x32, 0xA1, 0x99, 0xCA, 0x05, 0x22, 0x0C, 0x0F, 0xE0, 0xBB, 0x26, 0x4E, 0x69, 0x4B, 0xD0, - 0xD3, 0x05, 0x26, 0x4C, 0x03, 0x30, 0x08, 0x19, 0x83, 0x81, 0x62, 0x10, 0xC1, 0x99, 0x57, 0xA7, - 0x12, 0x7E, 0x99, 0x34, 0x6E, 0x69, 0x13, 0x71, 0x98, 0xC3, 0xA3, 0xA3, 0xE0, 0x23, 0x02, 0x1E, - 0x47, 0x78, 0xE9, 0x9D, 0x98, 0x6A, 0xC5, 0x9B, 0xA9, 0xA6, 0x00, 0xE2, 0x8E, 0xA3, 0xAA, 0x43, - 0x8C, 0x24, 0x03, 0x02, 0x2F, 0x3B, 0x76, 0x4F, 0x76, 0x83, 0x84, 0x36, 0x40, 0x11, 0x7E, 0xB8, - 0xE3, 0x20, 0x5B, 0x1A, 0x5B, 0xC2, 0xDF, 0x44, 0x2D, 0x81, 0x9B, 0xD7, 0x51, 0x80, 0xBC, 0x12, - 0x2A, 0x8A, 0xAE, 0xFC, 0xAD, 0x07, 0x78, 0xBF, 0xCF, 0x2D, 0xC4, 0x7C, 0x8A, 0x90, 0x8A, 0xE0, - 0x38, 0x1A, 0xAF, 0x43, 0xBE, 0x84, 0xC6, 0xDB, 0x3C, 0xD9, 0xCD, 0xF6, 0x05, 0xD3, 0x88, 0xC6, - 0x62, 0x6B, 0x40, 0x35, 0x91, 0xFF, 0x26, 0x76, 0x3D, 0x81, 0x86, 0xA8, 0x3A, 0xAB, 0x80, 0x02, - 0x3B, 0x80, 0xC0, 0x8E, 0x70, 0x7C, 0x41, 0x30, 0x26, 0xB3, 0x4A, 0xC6, 0xC6, 0xD1, 0xE7, 0x17, - 0x30, 0x60, 0xE2, 0xF7, 0x25, 0x66, 0x10, 0xD5, 0x94, 0x53, 0xC4, 0xC9, 0x59, 0xEF, 0xE9, 0x73, - 0x5A, 0x4F, 0x9F, 0xFC, 0x80, 0x85, 0x04, 0x09, 0x91, 0xB9, 0x20, 0x9A, 0xD4, 0x80, 0x3A, 0x52, - 0x8B, 0x8B, 0x9B, 0x00, 0x03, 0x8B, 0x6B, 0x00, 0x60, 0xD2, 0xC9, 0x9B, 0xC8, 0x86, 0x55, 0x04, - 0x98, 0x24, 0x02, 0x62, 0x01, 0xB1, 0xB1, 0xAD, 0xC6, 0x35, 0x01, 0x19, 0x01, 0x02, 0x1C, 0x74, - 0x11, 0x11, 0x4E, 0x0B, 0x53, 0x20, 0x28, 0xFA, 0xBE, 0x3C, 0x77, 0x0B, 0x86, 0x5D, 0xD3, 0x0E, - 0x60, 0xC1, 0x95, 0x30, 0x02, 0x4A, 0xA1, 0x42, 0xCC, 0x95, 0x7B, 0x30, 0x52, 0xD0, 0xB0, 0xB1, - 0xE0, 0x76, 0x9D, 0xC4, 0xA8, 0x2B, 0x0C, 0xD4, 0xD9, 0xAA, 0x7C, 0x30, 0xD7, 0xD5, 0x4C, 0x89, - 0x92, 0x44, 0xE4, 0x70, 0x97, 0xE5, 0xD8, 0x68, 0x7D, 0x60, 0x94, 0x0F, 0xAA, 0x42, 0xAE, 0xA4, - 0xF0, 0xB4, 0xEF, 0x33, 0x41, 0xD2, 0x4B, 0x04, 0x92, 0x6A, 0x6B, 0xEC, 0x4C, 0xF9, 0x2F, 0xF7, - 0xDF, 0xC5, 0x6F, 0xBF, 0xFE, 0x6F, 0xF1, 0xE8, 0x77, 0xD8, 0xA2, 0x58, 0xC8, 0x59, 0x6F, 0xCD, - 0x3F, 0xEC, 0xB2, 0xF5, 0x33, 0xC7, 0x7A, 0x7B, 0xE0, 0x80, 0x00, 0x53, 0x7D, 0x11, 0x30, 0x7C, - 0x25, 0x56, 0xF9, 0xF2, 0x54, 0xEB, 0xFC, 0x3B, 0x72, 0x36, 0x61, 0x39, 0xBF, 0xCA, 0xA6, 0xBF, - 0xD7, 0xF9, 0x82, 0xA5, 0xB7, 0xFF, 0xFF, 0x7E, 0xC3, 0xD7, 0xA3, 0x5E, 0x44, 0xA5, 0x1E, 0xB0, - 0x85, 0x1C, 0x09, 0x98, 0xB2, 0x51, 0xF5, 0xE5, 0xFB, 0x18, 0x1F, 0x50, 0xA8, 0x0C, 0xC2, 0xC0, - 0xD3, 0xEA, 0x14, 0x0C, 0xD4, 0x14, 0x30, 0xE8, 0x18, 0xCD, 0x4B, 0xC3, 0x39, 0x9B, 0x4C, 0x52, - 0x80, 0x07, 0x30, 0xD7, 0x49, 0xFF, 0xFB, 0x92, 0x64, 0x69, 0x0E, 0x04, 0x2A, 0x32, 0xC9, 0x93, - 0x9A, 0x5A, 0xF0, 0x30, 0xC8, 0x09, 0xB7, 0x0C, 0x23, 0x9E, 0x51, 0xC8, 0xCB, 0x22, 0x4E, 0x69, - 0x6F, 0x40, 0xCD, 0x84, 0xA6, 0x8C, 0x14, 0x08, 0x10, 0xA0, 0xC0, 0x09, 0xBC, 0x60, 0xA3, 0x39, - 0xA6, 0x19, 0x66, 0x87, 0x06, 0x03, 0x05, 0xC6, 0x6E, 0x1B, 0x00, 0xA9, 0x82, 0xD9, 0x91, 0x13, - 0x59, 0xC6, 0x43, 0x21, 0xF5, 0x26, 0x10, 0x05, 0x18, 0x59, 0x08, 0xF0, 0x27, 0xF9, 0x8C, 0x03, - 0x8F, 0x2B, 0xD4, 0x92, 0x54, 0x63, 0x02, 0x9E, 0x9A, 0xE8, 0xF2, 0x15, 0x1F, 0x28, 0x6C, 0x35, - 0xAA, 0xCD, 0xB2, 0x88, 0x21, 0x82, 0xED, 0xA9, 0x8C, 0x09, 0x11, 0x81, 0x22, 0x0B, 0x72, 0x34, - 0xB5, 0x4B, 0x8D, 0xC9, 0x46, 0xC5, 0x22, 0xD2, 0x41, 0x51, 0x2C, 0x66, 0x48, 0xFC, 0x91, 0x7F, - 0x0B, 0x68, 0xAF, 0xFF, 0xE6, 0x55, 0xC8, 0xE8, 0x59, 0x35, 0x10, 0x23, 0x18, 0x30, 0x79, 0x7D, - 0xA8, 0x3C, 0xB2, 0x4B, 0xD2, 0xBF, 0x17, 0x5B, 0x28, 0xBB, 0xFB, 0x80, 0x04, 0x9D, 0xB0, 0xBB, - 0x66, 0x18, 0x15, 0xE8, 0x20, 0x01, 0xB0, 0x4C, 0x31, 0xEB, 0x8A, 0x07, 0x16, 0x4C, 0x18, 0x14, - 0x20, 0x08, 0x52, 0xAA, 0x34, 0x33, 0xEB, 0xFF, 0x5F, 0xCD, 0x1F, 0x58, 0xD7, 0x11, 0x36, 0x59, - 0xC7, 0x4F, 0x98, 0x15, 0x08, 0x9D, 0x3A, 0xF5, 0xDA, 0xCF, 0xC9, 0x27, 0xAE, 0x40, 0x9D, 0x00, - 0x03, 0x09, 0x74, 0x54, 0x94, 0x78, 0x71, 0xDA, 0x99, 0x96, 0x02, 0xC0, 0xE3, 0xE1, 0x9F, 0x4B, - 0xC6, 0x33, 0xB1, 0x9A, 0x10, 0xA8, 0x21, 0x1C, 0xAC, 0xB3, 0x4C, 0x10, 0x40, 0x49, 0x93, 0x19, - 0x09, 0x83, 0x2D, 0x46, 0xF3, 0x20, 0x19, 0x61, 0x84, 0x0A, 0x42, 0xBC, 0x15, 0x99, 0x33, 0x95, - 0x19, 0x8F, 0x48, 0x66, 0xC5, 0x04, 0x0A, 0x59, 0xB0, 0x60, 0xD0, 0xF4, 0xF4, 0x58, 0x14, 0x31, - 0x70, 0x18, 0x0A, 0x8E, 0xA2, 0xB2, 0xF5, 0x7F, 0x9E, 0x87, 0xA8, 0x80, 0x0B, 0x25, 0x76, 0xE6, - 0xEB, 0xC4, 0x68, 0xD5, 0xFC, 0x36, 0x93, 0x0A, 0x5E, 0x34, 0x01, 0x7E, 0xEA, 0x5B, 0x3E, 0xA0, - 0x4C, 0x37, 0x13, 0x97, 0x00, 0xB0, 0x48, 0x4A, 0x12, 0x9F, 0x92, 0xEA, 0xDB, 0xFD, 0x09, 0xE8, - 0x70, 0xD8, 0x26, 0x1F, 0x1D, 0x2C, 0x50, 0x90, 0x8A, 0x7C, 0xE1, 0x29, 0xFF, 0xFA, 0xBF, 0xC5, - 0xB0, 0x00, 0x00, 0x00, 0x38, 0xAE, 0xE1, 0xC4, 0x3D, 0x50, 0xFF, 0xE5, 0x18, 0x2F, 0xFD, 0x29, - 0xAB, 0xB0, 0x20, 0x0C, 0x07, 0xC5, 0x42, 0xCF, 0x61, 0xE8, 0xB1, 0xF3, 0xCA, 0x38, 0x38, 0x0B, - 0xF7, 0x77, 0x49, 0xFE, 0xDF, 0xA0, 0xA7, 0xB5, 0xBA, 0x8D, 0xDE, 0x2F, 0x4B, 0x5E, 0x85, 0x5D, - 0x89, 0xF0, 0xEF, 0x4A, 0x56, 0x00, 0x96, 0x15, 0xE5, 0x05, 0x82, 0x33, 0xBA, 0x58, 0x52, 0x00, - 0x20, 0x73, 0x8A, 0x1C, 0x3B, 0x04, 0xB0, 0x09, 0xD3, 0xDB, 0x08, 0xC4, 0x0C, 0x34, 0xEB, 0x0C, - 0xD9, 0xF3, 0x0F, 0x54, 0xF8, 0x11, 0x06, 0xFF, 0xFB, 0x92, 0x64, 0x6C, 0x0C, 0x04, 0x0A, 0x33, - 0x49, 0x93, 0x9A, 0x3B, 0x60, 0x34, 0xA1, 0x39, 0xCA, 0x18, 0x29, 0x00, 0x0D, 0x94, 0x81, 0x2A, - 0x4D, 0xEB, 0x06, 0xC0, 0xCA, 0x13, 0x28, 0xE4, 0x10, 0x0F, 0x0E, 0x5F, 0x2B, 0x08, 0xD6, 0x01, - 0x91, 0x13, 0x60, 0x84, 0x11, 0xD1, 0x03, 0x12, 0x26, 0x0B, 0x6F, 0x16, 0xC2, 0xEA, 0x86, 0xDB, - 0x8B, 0x59, 0x5D, 0x0B, 0x29, 0xED, 0x4A, 0x96, 0x53, 0x23, 0x94, 0x8F, 0x2A, 0x5F, 0x05, 0x43, - 0xAF, 0x3F, 0x60, 0x88, 0x25, 0x83, 0x75, 0xD6, 0x63, 0xE5, 0xE1, 0x79, 0x3D, 0xFD, 0xC3, 0x39, - 0x4C, 0x1F, 0x9D, 0xD6, 0x72, 0xF2, 0xD5, 0x82, 0xCF, 0xD7, 0x2A, 0xE2, 0x3F, 0x7A, 0x25, 0x83, - 0xAB, 0x3B, 0xFF, 0xF6, 0xAA, 0x98, 0x10, 0x02, 0x84, 0x3E, 0xA2, 0x4F, 0x27, 0x93, 0x79, 0xE7, - 0x46, 0x69, 0x1F, 0xD7, 0xE6, 0x14, 0x79, 0xD2, 0x8E, 0x5A, 0x10, 0xF4, 0x73, 0x0B, 0x3C, 0x46, - 0x39, 0x03, 0x8D, 0x20, 0xA8, 0x15, 0x43, 0x8E, 0xB4, 0xF2, 0xCA, 0xC7, 0xCE, 0x3A, 0x35, 0x0B, - 0x7C, 0x73, 0x54, 0xDB, 0x2E, 0xD9, 0x72, 0x6B, 0x00, 0x00, 0x5C, 0x02, 0xA5, 0x29, 0x83, 0x98, - 0x15, 0x38, 0x41, 0x56, 0xC6, 0x42, 0xB4, 0x60, 0x70, 0x07, 0xC7, 0xEE, 0x6C, 0xA6, 0x25, 0x10, - 0x80, 0xE1, 0x93, 0x04, 0x03, 0x07, 0x41, 0x05, 0xA4, 0x35, 0x55, 0x8C, 0x3C, 0xB3, 0x66, 0x28, - 0xE4, 0x8C, 0x5D, 0xA6, 0x0C, 0xAC, 0x49, 0x3E, 0x0C, 0x69, 0x84, 0x2D, 0xC1, 0x73, 0xB2, 0x14, - 0x99, 0x7D, 0xD6, 0x32, 0x74, 0xB4, 0xE9, 0x5B, 0xA4, 0xBA, 0xD9, 0x3B, 0xC8, 0xA0, 0x09, 0x76, - 0xFB, 0xE9, 0xAF, 0xB4, 0x8A, 0x66, 0x02, 0x9B, 0xF6, 0xDC, 0x07, 0x79, 0x38, 0x40, 0xA0, 0x58, - 0x9C, 0xA9, 0xD6, 0x64, 0xF1, 0xB2, 0x0C, 0x98, 0x0B, 0x89, 0x21, 0x61, 0xA7, 0x51, 0xA5, 0x1B, - 0xFA, 0x96, 0x6F, 0xC7, 0x27, 0x16, 0x3E, 0xEE, 0x9A, 0x92, 0x8E, 0xB4, 0xA5, 0xB8, 0x7F, 0x52, - 0x8B, 0xC0, 0x10, 0x00, 0x00, 0x01, 0x0A, 0xED, 0x80, 0x09, 0x14, 0x52, 0xE8, 0xDC, 0x2B, 0x28, - 0x0C, 0x3D, 0x71, 0x6B, 0x93, 0x54, 0x62, 0x38, 0x62, 0xCC, 0x32, 0xB6, 0x51, 0x41, 0xE1, 0x1B, - 0x44, 0x6F, 0x58, 0x60, 0x55, 0x81, 0xC1, 0x40, 0xB9, 0x87, 0xAD, 0x4C, 0x0F, 0x45, 0x60, 0x66, - 0x0A, 0x61, 0xC5, 0xC2, 0x86, 0xB2, 0x07, 0x83, 0x72, 0x67, 0x24, 0x42, 0x23, 0x14, 0x43, 0x8C, - 0xB2, 0x1A, 0x30, 0x98, 0xB8, 0x2A, 0x3E, 0x38, 0xC0, 0x44, 0xCD, 0xE0, 0xA3, 0x46, 0x95, 0xCC, - 0xA2, 0x11, 0x26, 0x5E, 0x81, 0x03, 0x26, 0x0F, 0x29, 0x1B, 0x8C, 0x82, 0x7D, 0x6E, 0x09, 0x46, - 0x31, 0xA3, 0x13, 0x39, 0x94, 0xA7, 0xE0, 0xC0, 0x00, 0x84, 0x61, 0x11, 0xDC, 0x76, 0x48, 0xCC, - 0xD6, 0x4B, 0x59, 0x77, 0x95, 0x33, 0x6F, 0x22, 0x6A, 0xE4, 0x84, 0x2A, 0xDC, 0x43, 0x34, 0x72, - 0x68, 0xEF, 0xDE, 0x4B, 0x9E, 0x6A, 0x48, 0xCB, 0x5C, 0xFF, 0xFB, 0x92, 0x64, 0x80, 0x8E, 0x03, - 0xC9, 0x2F, 0x49, 0x9B, 0x7A, 0x3A, 0xF0, 0x35, 0x41, 0x09, 0xCD, 0x0C, 0x02, 0x00, 0x0F, 0x2C, - 0xBB, 0x26, 0x4E, 0x68, 0xED, 0x80, 0xDA, 0x85, 0xE7, 0x34, 0x30, 0x88, 0x00, 0x46, 0x35, 0x50, - 0xBF, 0xCB, 0xC1, 0xDE, 0xA8, 0xD6, 0x17, 0x45, 0xC2, 0x82, 0xE5, 0x1E, 0x1F, 0x73, 0xCD, 0x11, - 0xF4, 0x16, 0xCA, 0x7F, 0xAF, 0xF9, 0x07, 0x0B, 0xA2, 0x1D, 0xA2, 0xD9, 0x88, 0xDB, 0x85, 0xCC, - 0x3F, 0x6C, 0x53, 0xA9, 0xD0, 0x80, 0x60, 0x00, 0x00, 0x92, 0xEF, 0xC2, 0x85, 0x75, 0x1D, 0xF0, - 0x4D, 0xA7, 0x0E, 0x93, 0xC5, 0xA4, 0x8B, 0x5C, 0x49, 0x0C, 0x61, 0xCA, 0xC4, 0xE3, 0x87, 0xFE, - 0x8A, 0x9A, 0xC7, 0xD9, 0x01, 0xF6, 0x8A, 0x77, 0xB1, 0xDA, 0x14, 0x6E, 0xA7, 0xA0, 0x44, 0x85, - 0xBE, 0xE7, 0x58, 0x2A, 0x0B, 0xB8, 0x28, 0x68, 0xB5, 0xF3, 0x0A, 0x00, 0x00, 0x54, 0x02, 0x39, - 0x5C, 0x31, 0xC4, 0x16, 0x02, 0x61, 0x44, 0x46, 0x36, 0x16, 0x61, 0x82, 0x47, 0x7F, 0xE4, 0x0D, - 0x34, 0x3B, 0xC6, 0xC3, 0x0A, 0x11, 0x07, 0x33, 0x98, 0x18, 0x4A, 0x40, 0x98, 0xB8, 0xB8, 0x49, - 0x49, 0x8B, 0x02, 0x18, 0x08, 0x98, 0xB1, 0x40, 0x35, 0x1C, 0x52, 0xFA, 0x3C, 0xA1, 0x03, 0x54, - 0x6F, 0x99, 0xC2, 0xD6, 0x87, 0x69, 0x65, 0x71, 0x88, 0xCB, 0x49, 0x47, 0xC6, 0x5B, 0x0A, 0x7F, - 0xD2, 0x41, 0xD8, 0x85, 0x2D, 0x55, 0xD5, 0x4D, 0x61, 0x1B, 0xDA, 0xB4, 0xDC, 0xA5, 0x0E, 0xC0, - 0xE0, 0x17, 0x1E, 0xA4, 0x6B, 0xB6, 0x76, 0x35, 0xB6, 0xE4, 0x9F, 0xFB, 0x3B, 0xE9, 0x1E, 0xA9, - 0x3A, 0xFB, 0xF3, 0x7D, 0xBF, 0x7C, 0x75, 0x3A, 0x40, 0x29, 0xA2, 0xE1, 0x6C, 0xA6, 0x09, 0x33, - 0xDF, 0xF9, 0xEC, 0x5A, 0xF4, 0x54, 0x21, 0x91, 0x44, 0x15, 0x00, 0x00, 0x00, 0x12, 0x52, 0x40, - 0x32, 0x58, 0x17, 0x6B, 0x29, 0xFE, 0xA2, 0x5E, 0xC6, 0x38, 0x3F, 0x61, 0x7E, 0x9A, 0xA5, 0xF7, - 0x6D, 0x93, 0xDF, 0xA3, 0xE8, 0xD5, 0x12, 0x06, 0x5A, 0x24, 0x17, 0x99, 0xA4, 0xAA, 0x88, 0xD8, - 0x75, 0x40, 0x05, 0x12, 0x08, 0x14, 0x70, 0x77, 0x33, 0x5B, 0x8B, 0xA2, 0xE6, 0x4C, 0x40, 0x7E, - 0x4E, 0x92, 0x81, 0x01, 0x48, 0x8F, 0x1D, 0xC0, 0x22, 0x40, 0xC5, 0xC1, 0x8C, 0x50, 0x6C, 0xC3, - 0x7C, 0xC2, 0x07, 0x0E, 0x9E, 0xCC, 0x59, 0xB8, 0xD4, 0x90, 0x4C, 0xE4, 0x8C, 0x51, 0xCF, 0x39, - 0x85, 0xE4, 0x4F, 0xB3, 0xCD, 0x12, 0x10, 0x0D, 0x84, 0xDC, 0x24, 0x13, 0x06, 0x1C, 0x50, 0xFB, - 0x3A, 0x87, 0x5D, 0xE1, 0xA4, 0xD4, 0x87, 0x10, 0xEE, 0xA4, 0x1C, 0x44, 0xBD, 0xB1, 0x7D, 0xE2, - 0x5F, 0x8A, 0xA9, 0x4A, 0xD9, 0x60, 0xE8, 0x3F, 0xEE, 0x59, 0x59, 0xB0, 0x6C, 0xC8, 0x00, 0x05, - 0xDE, 0xAE, 0x25, 0x4C, 0xC6, 0xD8, 0xEC, 0x7D, 0xD4, 0xCD, 0x39, 0xF7, 0x77, 0xBF, 0xDA, 0xF2, - 0xDE, 0x9F, 0x3B, 0xAF, 0x39, 0x9D, 0xE0, 0xEA, 0x50, 0x9C, 0x92, 0xFF, 0xFB, 0x90, 0x64, 0x90, - 0x06, 0x43, 0xE8, 0x31, 0x4A, 0x1B, 0x79, 0x4B, 0xD0, 0x36, 0x21, 0x39, 0xED, 0x04, 0x23, 0x04, - 0x8F, 0x08, 0xC3, 0x28, 0xCD, 0xE4, 0xCB, 0xC0, 0xD1, 0x83, 0xA7, 0x28, 0x30, 0x0C, 0xC8, 0xA1, - 0x14, 0xEB, 0xE7, 0x3F, 0xDC, 0xBF, 0xF9, 0x05, 0xF4, 0xC4, 0xB8, 0x00, 0x00, 0x91, 0xEF, 0xC2, - 0x0A, 0xBC, 0x6A, 0x74, 0x46, 0x07, 0x07, 0xC0, 0xD1, 0x67, 0x24, 0x64, 0x58, 0xE2, 0x5B, 0xB1, - 0x52, 0x1A, 0xDD, 0x94, 0x4B, 0xB7, 0xFA, 0xED, 0xBC, 0x0A, 0x9A, 0x2E, 0x59, 0xF3, 0x8D, 0x4A, - 0xAB, 0x68, 0x86, 0x69, 0x85, 0xD8, 0x15, 0x0A, 0x03, 0x11, 0x05, 0x77, 0xB5, 0xCC, 0xBA, 0x00, - 0x0D, 0x09, 0x96, 0xBC, 0x61, 0xE2, 0x87, 0x24, 0x9A, 0x65, 0x43, 0x21, 0x62, 0x83, 0x52, 0x7A, - 0x35, 0xC2, 0x83, 0x0F, 0x08, 0x37, 0x09, 0xE3, 0x4E, 0x0D, 0x33, 0x78, 0x80, 0x75, 0xE3, 0x04, - 0xCC, 0xD0, 0x0F, 0x22, 0xD0, 0x17, 0x7A, 0x62, 0x86, 0x9A, 0x44, 0x42, 0xE7, 0xC7, 0x04, 0xCA, - 0xDA, 0x50, 0xF5, 0xF7, 0xEA, 0x8C, 0x64, 0x0A, 0x0B, 0x3B, 0x74, 0xCA, 0xB5, 0x35, 0x57, 0x02, - 0x2F, 0xB5, 0x06, 0xD2, 0x9D, 0x54, 0x8B, 0xBF, 0x03, 0xC4, 0x9B, 0x8A, 0x4C, 0x5C, 0xB7, 0x3B, - 0x14, 0x7F, 0x62, 0x45, 0xCE, 0x31, 0x64, 0x6A, 0x36, 0x06, 0x7C, 0xDA, 0x4B, 0x02, 0x27, 0x4A, - 0x8B, 0x98, 0x59, 0xC5, 0x7D, 0x1B, 0x73, 0x17, 0x3B, 0x5C, 0x73, 0x71, 0x97, 0x58, 0x72, 0x1D, - 0x9A, 0x70, 0x61, 0xF8, 0x38, 0xF2, 0xB2, 0xAE, 0x2C, 0xA7, 0xBB, 0xFF, 0x4C, 0x80, 0x01, 0x20, - 0xC9, 0x31, 0x0E, 0x4F, 0x7A, 0xF5, 0x24, 0xAC, 0x1D, 0xE1, 0xB8, 0xAC, 0xD0, 0x53, 0x31, 0x35, - 0x10, 0x0B, 0x46, 0x24, 0x85, 0x2C, 0xB7, 0xAB, 0xFE, 0x54, 0x36, 0x02, 0x80, 0x8B, 0x08, 0x1E, - 0x4C, 0x1C, 0x1F, 0xDB, 0xB1, 0x8B, 0x7D, 0x0B, 0xB5, 0xA5, 0x9D, 0x11, 0x3C, 0x87, 0x14, 0x0C, - 0x22, 0x0D, 0xD4, 0x42, 0x0E, 0x19, 0x66, 0x46, 0x93, 0x07, 0x20, 0x10, 0x98, 0xC6, 0xB2, 0xA8, - 0xCA, 0x4A, 0xF0, 0x38, 0x5C, 0x30, 0x60, 0x71, 0x30, 0x88, 0x11, 0x18, 0x36, 0x4C, 0x41, 0x14, - 0x44, 0x62, 0xD1, 0x93, 0xA3, 0xA9, 0x95, 0xE3, 0x29, 0x82, 0xA1, 0xB8, 0x90, 0x78, 0xCA, 0x4D, - 0x94, 0x01, 0x75, 0x86, 0x04, 0x18, 0xEF, 0x04, 0xC9, 0x48, 0x51, 0x53, 0xB9, 0x31, 0xC6, 0x66, - 0x61, 0x40, 0x80, 0xE8, 0xAC, 0xF5, 0x8B, 0x0D, 0x82, 0x3D, 0xCA, 0x1C, 0x44, 0xB6, 0x45, 0x2B, - 0x57, 0x8F, 0xFE, 0x32, 0xF9, 0x22, 0x82, 0x26, 0x22, 0xF8, 0x58, 0x84, 0x66, 0x54, 0xCF, 0x13, - 0x42, 0x6D, 0x59, 0xC2, 0xCB, 0x17, 0x49, 0x43, 0xA7, 0x46, 0xEF, 0x49, 0xD2, 0x45, 0xBF, 0x47, - 0xAE, 0xB1, 0xD8, 0x3E, 0x8E, 0x30, 0x80, 0x74, 0x45, 0xE9, 0xFE, 0x34, 0x05, 0x16, 0x1B, 0x24, - 0xE7, 0x88, 0xDE, 0x8D, 0x40, 0x00, 0x08, 0x22, 0x09, 0x20, 0x16, 0x82, 0xFF, 0xFB, 0x92, 0x64, - 0x9E, 0x8E, 0x03, 0xED, 0x30, 0x49, 0x93, 0x7A, 0x42, 0xF0, 0x32, 0x61, 0x7A, 0x19, 0x08, 0x02, - 0x33, 0x90, 0x90, 0xB5, 0x22, 0x4E, 0xE1, 0xAF, 0x40, 0xBE, 0x1B, 0x27, 0xE8, 0x70, 0x0F, 0xC2, - 0xD3, 0x77, 0x47, 0xAB, 0xCF, 0x4F, 0xAF, 0x4B, 0x52, 0xB5, 0x4A, 0xFD, 0xBF, 0x37, 0xA7, 0xFF, - 0xF4, 0x53, 0x68, 0x94, 0x98, 0xEA, 0x47, 0x24, 0xBC, 0xA5, 0x82, 0x60, 0xE8, 0xE0, 0x15, 0xD7, - 0xA2, 0xA5, 0x4B, 0xBE, 0xC6, 0x7F, 0xEA, 0xC0, 0x00, 0x04, 0x02, 0xAB, 0xB6, 0xD8, 0x66, 0x7E, - 0x1C, 0x34, 0x19, 0x33, 0x69, 0x97, 0xF2, 0x08, 0xC8, 0xAA, 0x25, 0x45, 0x24, 0x48, 0x09, 0x2B, - 0xA0, 0xAF, 0x0B, 0xD1, 0x04, 0x2A, 0x47, 0x5D, 0xA8, 0xE1, 0x48, 0x6C, 0x5C, 0xD3, 0x51, 0x79, - 0x3D, 0x75, 0x49, 0x9D, 0xB1, 0x4A, 0xA4, 0x48, 0xF1, 0xB5, 0x6F, 0xD4, 0x29, 0xEE, 0xA2, 0xE7, - 0x8D, 0x5C, 0x6B, 0x0F, 0x52, 0x65, 0xF3, 0x1C, 0xDA, 0x3F, 0xF9, 0xC6, 0x00, 0xA5, 0xE5, 0x33, - 0x01, 0x8B, 0xFA, 0x7D, 0x9E, 0x45, 0xBE, 0xE4, 0xEF, 0x6E, 0x2F, 0xFF, 0xF4, 0xA8, 0x00, 0x00, - 0x02, 0x00, 0x62, 0x39, 0x20, 0xA8, 0x4E, 0xF5, 0xEA, 0x65, 0x9F, 0xA3, 0x5A, 0x61, 0xF5, 0xAF, - 0xEB, 0xF7, 0xF6, 0xCD, 0x14, 0x15, 0x54, 0x98, 0xBE, 0xAE, 0xD4, 0x67, 0x0E, 0x8D, 0xCD, 0xEC, - 0x1A, 0x35, 0x08, 0x42, 0x9D, 0x2A, 0xB7, 0x92, 0x5A, 0xA6, 0x94, 0xAC, 0xDE, 0xE5, 0x37, 0xFE, - 0xE0, 0x04, 0x20, 0x9B, 0x7E, 0x04, 0x43, 0xA3, 0x32, 0xFC, 0x4C, 0x7C, 0x25, 0x05, 0x0C, 0x0C, - 0x18, 0x61, 0x3B, 0x12, 0xBC, 0x2E, 0x0A, 0x32, 0x91, 0x90, 0x59, 0x6E, 0x68, 0x78, 0x29, 0x8E, - 0x06, 0x66, 0x51, 0x58, 0x1A, 0x78, 0xC2, 0x30, 0xE9, 0x1A, 0x37, 0x98, 0xB0, 0x6C, 0x7F, 0x92, - 0x36, 0x83, 0x1C, 0x2E, 0x48, 0x4B, 0x48, 0xA2, 0x80, 0xD1, 0x20, 0x80, 0x2F, 0x93, 0x24, 0x93, - 0x0F, 0x62, 0x8B, 0x35, 0x85, 0x4C, 0x4A, 0x42, 0x0D, 0x2D, 0xA8, 0x71, 0x4C, 0x0B, 0xE8, 0xD6, - 0x92, 0x28, 0xB9, 0xAB, 0x41, 0x81, 0x50, 0xC1, 0x2C, 0x8E, 0x56, 0xC4, 0x99, 0x62, 0x5E, 0xBD, - 0x2D, 0xAC, 0xFB, 0xAC, 0xA1, 0x45, 0xCD, 0x30, 0x3A, 0x46, 0x43, 0xE6, 0x5D, 0x34, 0x46, 0xA1, - 0x9A, 0x76, 0x61, 0xF3, 0x20, 0x22, 0x69, 0xB9, 0x8F, 0xEF, 0xF2, 0x68, 0x74, 0xB2, 0x51, 0x88, - 0x80, 0x00, 0x01, 0xED, 0xF8, 0x08, 0xAD, 0xF1, 0xCF, 0xA2, 0xBE, 0xFF, 0x15, 0x76, 0x26, 0x80, - 0x9F, 0x3C, 0xCB, 0x3D, 0x7E, 0x77, 0x6B, 0x37, 0xEA, 0x5F, 0x6D, 0x1E, 0x5B, 0x53, 0x03, 0x53, - 0x90, 0x2A, 0x03, 0x99, 0x20, 0x54, 0x0E, 0x4F, 0x16, 0x69, 0xB7, 0x8B, 0x0D, 0xA8, 0x6C, 0xB2, - 0xE9, 0x5C, 0x16, 0x00, 0x89, 0x08, 0x89, 0x28, 0x30, 0x8C, 0xAC, 0xE7, 0xD3, 0xC2, 0x3F, 0xCC, - 0x98, 0x6C, 0xCC, 0x4D, 0x4C, 0x69, 0xB8, 0xD3, 0x8F, 0x0D, 0x11, 0xD4, 0xCD, 0xCD, 0xFF, 0xFB, - 0x92, 0x64, 0xAB, 0x80, 0x02, 0xB1, 0x2D, 0xD0, 0x53, 0x0B, 0x2C, 0x34, 0x33, 0x65, 0x0A, 0x0D, - 0x1C, 0x02, 0xD0, 0x8F, 0xCC, 0xB7, 0x20, 0x4E, 0x65, 0x4F, 0x40, 0xD0, 0x95, 0x27, 0x28, 0x30, - 0x8A, 0x30, 0xCD, 0xA2, 0x30, 0xB0, 0x7C, 0x66, 0x21, 0x62, 0xE4, 0xA7, 0x49, 0xC0, 0x60, 0x26, - 0xA6, 0x54, 0x02, 0x71, 0x1C, 0x67, 0x9E, 0xAF, 0x55, 0x38, 0xD0, 0x23, 0xEC, 0x85, 0xC3, 0x49, - 0x11, 0xD6, 0x5B, 0xE6, 0xDA, 0x22, 0xD1, 0x1A, 0x3C, 0x82, 0x69, 0x1D, 0xF9, 0x3C, 0xC1, 0x95, - 0xA1, 0x8E, 0x2E, 0xEB, 0xAC, 0x11, 0xE9, 0x86, 0x9B, 0xBC, 0xCB, 0x42, 0x54, 0x89, 0x1C, 0x5A, - 0xE6, 0xE5, 0x4B, 0x24, 0x77, 0xC6, 0xC7, 0xF3, 0xA9, 0x8B, 0x8F, 0x5B, 0x09, 0x6F, 0xF4, 0x55, - 0x88, 0x7A, 0x89, 0x77, 0xF9, 0x6E, 0xFF, 0x73, 0x85, 0xEE, 0x24, 0xE6, 0xE7, 0xBC, 0x93, 0xFD, - 0x41, 0x66, 0xC3, 0x60, 0xE5, 0xD6, 0xFF, 0xD3, 0x55, 0xF8, 0x00, 0x00, 0x00, 0x06, 0xBB, 0x70, - 0xCF, 0x20, 0x1C, 0x0A, 0x2E, 0x17, 0xA7, 0x4A, 0xDC, 0xB4, 0x77, 0xD8, 0xF5, 0x69, 0xB3, 0xF1, - 0x71, 0x71, 0x6E, 0xC6, 0xD1, 0x4D, 0x85, 0x8D, 0x4C, 0xA9, 0xBC, 0xF3, 0x5F, 0xD4, 0x0A, 0x8C, - 0x7C, 0x59, 0x4B, 0x52, 0xEB, 0x7A, 0x93, 0x30, 0x03, 0x11, 0x1B, 0x38, 0x41, 0x95, 0xBF, 0x46, - 0x33, 0x10, 0x1E, 0x99, 0x92, 0x6A, 0x70, 0x81, 0x8D, 0xC8, 0x26, 0x15, 0x3A, 0x18, 0xF9, 0xBC, - 0x6D, 0xA0, 0x01, 0x85, 0x08, 0x06, 0x4C, 0x12, 0x1B, 0x7C, 0xE2, 0x1C, 0x67, 0x19, 0x09, 0x98, - 0x38, 0xC8, 0x73, 0xFA, 0x99, 0x82, 0xCA, 0xC1, 0x82, 0xD3, 0x53, 0xA4, 0x90, 0x00, 0x8E, 0x08, - 0x48, 0x11, 0x91, 0x45, 0x08, 0x88, 0x8D, 0x60, 0xD5, 0xDF, 0xCC, 0x12, 0x71, 0x5D, 0xE1, 0x2A, - 0xAE, 0x8D, 0x8D, 0x6E, 0x52, 0xF2, 0x1C, 0x01, 0x41, 0xE9, 0xA3, 0x6D, 0x0D, 0x64, 0x0F, 0x93, - 0x47, 0x56, 0x34, 0xC0, 0x77, 0xC1, 0x29, 0x95, 0x1F, 0x67, 0xF0, 0x09, 0x40, 0x49, 0xD0, 0xF4, - 0xB3, 0x4C, 0x7E, 0xD6, 0x34, 0x97, 0x26, 0x64, 0xF1, 0xCE, 0xF3, 0x23, 0x72, 0xF7, 0x59, 0x8A, - 0xF1, 0xC1, 0xB1, 0xFF, 0x97, 0xF9, 0xF2, 0x13, 0x48, 0x1C, 0x87, 0x79, 0xD9, 0x53, 0xA3, 0x66, - 0x87, 0xEB, 0x9D, 0xF7, 0xEB, 0xF7, 0x69, 0x80, 0x90, 0x88, 0xB2, 0x01, 0xE5, 0xE6, 0x12, 0x20, - 0x24, 0x9E, 0xE6, 0xFF, 0xE5, 0x03, 0xF5, 0xC8, 0x67, 0xF4, 0x76, 0xFF, 0xFA, 0x1C, 0xAB, 0xEB, - 0xA0, 0xB9, 0xEB, 0x3F, 0xF4, 0xD9, 0x79, 0x7E, 0x48, 0x59, 0x93, 0x0F, 0x0C, 0x1F, 0x17, 0x38, - 0x6A, 0x98, 0x9E, 0xBA, 0xF3, 0x14, 0x15, 0x55, 0x00, 0x01, 0x86, 0x94, 0x5F, 0x52, 0xD4, 0x1B, - 0x26, 0xA8, 0x19, 0x0B, 0x01, 0x0D, 0x0C, 0x84, 0x07, 0x33, 0xDC, 0x3C, 0x42, 0x0D, 0x30, 0xE0, - 0x10, 0xC3, 0x01, 0x60, 0xEA, 0x49, 0x86, 0x0F, 0xA6, 0x36, 0x0D, 0x33, 0x23, 0x04, 0x3B, 0x8C, - 0xFF, 0xFB, 0x92, 0x64, 0xCC, 0x8C, 0x04, 0x13, 0x34, 0x48, 0x93, 0x79, 0x4B, 0xD0, 0x33, 0x60, - 0x99, 0xCA, 0x24, 0x02, 0x10, 0x11, 0x48, 0xD1, 0x1E, 0x0E, 0x65, 0x6F, 0x80, 0xC2, 0x87, 0xE9, - 0xB0, 0x30, 0x98, 0x6E, 0x2A, 0x19, 0x0E, 0x26, 0xA4, 0xC9, 0x19, 0x4A, 0x38, 0xA0, 0x24, 0x32, - 0x45, 0xF5, 0xD6, 0xB1, 0x06, 0x5A, 0x9E, 0x36, 0x18, 0x0A, 0x40, 0x89, 0x19, 0xFD, 0x6D, 0x96, - 0x12, 0x05, 0x77, 0x04, 0x4C, 0x00, 0x12, 0x32, 0xAD, 0xCE, 0x42, 0xE6, 0x87, 0x1B, 0xF8, 0xC3, - 0xEC, 0xD3, 0x55, 0x91, 0x4B, 0xD8, 0xAC, 0x35, 0x0C, 0xB0, 0xF5, 0xAA, 0x94, 0x21, 0x34, 0xFA, - 0xF2, 0xD7, 0x28, 0x8D, 0xF9, 0xF8, 0xFA, 0xAE, 0x56, 0x19, 0xB4, 0x3D, 0x32, 0xBA, 0x39, 0x9C, - 0x70, 0xF5, 0xA8, 0xCA, 0x94, 0x8F, 0x6D, 0xBB, 0xD3, 0x94, 0x34, 0xD7, 0x19, 0xA5, 0x5D, 0x6F, - 0x77, 0xFE, 0xEA, 0x15, 0x8A, 0xE1, 0x2A, 0x90, 0x00, 0x01, 0xD0, 0x64, 0x25, 0x1D, 0xFC, 0x4B, - 0x43, 0x38, 0x44, 0x18, 0x95, 0x39, 0x05, 0x0F, 0x44, 0x2B, 0xAD, 0x37, 0xB3, 0x51, 0x73, 0xFD, - 0xB4, 0xFB, 0xFA, 0x85, 0x2E, 0xFB, 0x7F, 0x6A, 0x91, 0x42, 0x74, 0x2C, 0xD2, 0xE4, 0xD1, 0x12, - 0x16, 0xAD, 0x06, 0x46, 0xA7, 0x69, 0x49, 0xA4, 0x8A, 0x9D, 0x99, 0x05, 0x39, 0x45, 0xB3, 0x01, - 0x07, 0x33, 0x1E, 0xA3, 0x18, 0x0C, 0x22, 0x11, 0x30, 0x45, 0xF3, 0x10, 0xD9, 0x34, 0x59, 0x33, - 0x3E, 0x33, 0x18, 0x04, 0x0E, 0x32, 0x05, 0x34, 0x99, 0xA8, 0x58, 0x14, 0x04, 0xCA, 0xB9, 0xC0, - 0x4D, 0x26, 0x6C, 0x2A, 0x1D, 0x3E, 0x50, 0xF0, 0xD0, 0x48, 0x41, 0x9F, 0x13, 0x99, 0x64, 0x86, - 0xA9, 0xB5, 0x59, 0x12, 0x89, 0x26, 0x42, 0xFE, 0x8A, 0xC0, 0xA9, 0x7E, 0xBD, 0x1E, 0xE7, 0x3E, - 0x12, 0xF7, 0xE4, 0xCB, 0xD3, 0x4E, 0x39, 0x39, 0x1D, 0x0B, 0x89, 0x26, 0x69, 0x2B, 0xA0, 0x7B, - 0x57, 0x6E, 0x6D, 0xDA, 0x7B, 0x3F, 0x06, 0x83, 0xCC, 0x58, 0x77, 0x16, 0x5F, 0x7A, 0x74, 0x5A, - 0x8A, 0xFF, 0xFF, 0xCD, 0xDF, 0xAC, 0xF7, 0x88, 0x5A, 0x40, 0x6A, 0xFF, 0xA3, 0xF8, 0x80, 0xB0, - 0xF7, 0xFD, 0x1F, 0xFD, 0x34, 0x75, 0xFF, 0xFF, 0xFA, 0xD8, 0x02, 0x01, 0x61, 0x73, 0x7E, 0x0E, - 0x06, 0x0C, 0x68, 0x56, 0x20, 0xB0, 0x50, 0xAB, 0xB1, 0x7C, 0xDB, 0xF7, 0x0B, 0x72, 0xFF, 0xB7, - 0x80, 0x1D, 0x3E, 0xA2, 0x5A, 0x51, 0x57, 0x15, 0x3A, 0xED, 0xA7, 0x89, 0xB8, 0xE8, 0x58, 0x79, - 0x33, 0x8C, 0xB5, 0xB7, 0xA2, 0xC7, 0x29, 0x2C, 0xC5, 0x55, 0xE2, 0x8A, 0xA8, 0x91, 0xE6, 0x2C, - 0x26, 0x1B, 0x18, 0xBE, 0x4D, 0x34, 0x32, 0x38, 0x7C, 0x50, 0xA0, 0x65, 0xC5, 0xD1, 0xCA, 0xC8, - 0xA6, 0x2E, 0x20, 0x01, 0x00, 0xA6, 0x30, 0x10, 0x8F, 0x1F, 0x4C, 0x92, 0x3D, 0x36, 0x79, 0x54, - 0xD9, 0xAA, 0xE0, 0xC0, 0x48, 0x29, 0x50, 0x61, 0xC3, 0x91, 0x81, 0xC6, 0xA5, 0xB5, 0x52, 0xC1, - 0x20, 0xC8, 0xFF, 0xFB, 0x92, 0x64, 0xD3, 0x0E, 0x24, 0x5A, 0x33, 0xC8, 0x93, 0x98, 0x63, 0xD0, - 0x33, 0xC0, 0xE9, 0xCD, 0x05, 0x26, 0x00, 0x0F, 0xC8, 0xCB, 0x26, 0x6D, 0xE4, 0xD1, 0x00, 0xC8, - 0x83, 0x67, 0x34, 0x31, 0x0C, 0x48, 0xF3, 0x15, 0x12, 0x48, 0x82, 0xC5, 0x86, 0x8F, 0xB1, 0xF0, - 0x60, 0xC8, 0x3C, 0xBD, 0x20, 0xA5, 0xF2, 0x08, 0x0B, 0xA3, 0x06, 0x10, 0x4C, 0x58, 0xEB, 0x69, - 0x04, 0x8A, 0x52, 0x63, 0x35, 0xC5, 0x74, 0xF5, 0xA2, 0x4D, 0x84, 0xA3, 0x0E, 0x18, 0xD6, 0x24, - 0x12, 0xF8, 0xEB, 0xEF, 0x22, 0x18, 0x1F, 0x3A, 0x89, 0x50, 0xA6, 0xC6, 0x41, 0x44, 0xCE, 0x79, - 0x75, 0x77, 0xFF, 0xF1, 0x6B, 0xFC, 0x5A, 0xC5, 0xE7, 0xC6, 0xD6, 0x8F, 0x23, 0x0F, 0x71, 0xB7, - 0x05, 0xC4, 0x22, 0x65, 0xEE, 0xFD, 0x09, 0x6D, 0x8A, 0x00, 0x85, 0x00, 0x42, 0xC0, 0x54, 0x15, - 0x3B, 0x52, 0xDF, 0xD6, 0x99, 0xF3, 0x27, 0xEE, 0x4B, 0xB5, 0xFF, 0xE5, 0xC3, 0x62, 0x21, 0x64, - 0xA5, 0x6C, 0xFF, 0xB4, 0x83, 0x9E, 0xB9, 0x51, 0x84, 0xD6, 0x0F, 0x3C, 0x97, 0x16, 0xF9, 0xA0, - 0xC9, 0x66, 0x89, 0x0F, 0x0D, 0x0D, 0x12, 0x61, 0x21, 0xA2, 0xE0, 0x00, 0x41, 0x4E, 0xD7, 0x74, - 0x08, 0x81, 0xCE, 0x64, 0xA0, 0xE8, 0x87, 0x48, 0x8E, 0x00, 0x34, 0x46, 0x15, 0x58, 0x65, 0xE1, - 0x47, 0x00, 0x7C, 0x1C, 0xA0, 0x64, 0x4F, 0x06, 0x8A, 0xB4, 0x58, 0x7D, 0x3B, 0x34, 0x23, 0x98, - 0x77, 0x33, 0xE0, 0x23, 0x10, 0x03, 0x05, 0x09, 0x9C, 0x48, 0x41, 0x00, 0x0A, 0x0D, 0x98, 0x94, - 0xB7, 0x62, 0xAA, 0xE4, 0x64, 0xE9, 0xCA, 0xF9, 0x4C, 0x43, 0xED, 0x69, 0x85, 0x97, 0xDA, 0x1C, - 0x87, 0x19, 0xEA, 0xE9, 0x16, 0x53, 0x11, 0x68, 0x4E, 0xA2, 0x48, 0xC3, 0xAE, 0x4E, 0xA6, 0x63, - 0x6D, 0x6D, 0x43, 0x40, 0xC3, 0xAD, 0x9D, 0x0E, 0x47, 0x0B, 0x03, 0x56, 0x11, 0x4F, 0xA1, 0x83, - 0x15, 0x37, 0x49, 0xBD, 0xF9, 0x5E, 0xC8, 0x5C, 0xA8, 0x96, 0x22, 0x8F, 0xBF, 0xD0, 0x44, 0x51, - 0x59, 0x7F, 0xEE, 0x73, 0x11, 0x7B, 0xBB, 0xBF, 0xC5, 0xD5, 0xD8, 0x32, 0x77, 0xF4, 0x7F, 0x25, - 0x4C, 0x40, 0x00, 0x00, 0x0F, 0xB0, 0xFC, 0x4D, 0xCC, 0x7F, 0x0B, 0xD3, 0xFA, 0x7E, 0xFF, 0xF6, - 0xFE, 0x80, 0x71, 0x42, 0xB6, 0xE8, 0x47, 0xD7, 0x6B, 0xDD, 0x0E, 0xAA, 0x54, 0xB5, 0xDC, 0x97, - 0x1E, 0xC7, 0x0A, 0x3B, 0xFF, 0x4B, 0x84, 0x61, 0xC1, 0x42, 0x7A, 0xAE, 0x6B, 0x18, 0x39, 0x2A, - 0x03, 0xF6, 0xC8, 0xD5, 0xC0, 0x00, 0x00, 0x00, 0x51, 0x97, 0x79, 0x95, 0x66, 0x0B, 0x0C, 0x98, - 0x25, 0xA9, 0x8F, 0x05, 0x83, 0x87, 0x02, 0xA2, 0x60, 0x56, 0x90, 0x31, 0xC1, 0x91, 0x8B, 0x89, - 0x11, 0x99, 0x2A, 0x0A, 0x02, 0xC1, 0xC9, 0x03, 0x48, 0x06, 0xC6, 0x62, 0x28, 0x14, 0x15, 0x03, - 0x0E, 0x0B, 0x53, 0x07, 0x2A, 0x56, 0x18, 0x82, 0x26, 0x76, 0x21, 0xC3, 0x2C, 0x5A, 0xE9, 0x23, - 0x12, 0xE6, 0xD1, 0xC9, 0xFF, 0xFB, 0x92, 0x64, 0xDA, 0x0C, 0x04, 0x38, 0x33, 0xC8, 0x03, 0x98, - 0x5C, 0xB0, 0x33, 0x60, 0x0A, 0x0C, 0x04, 0x22, 0x5F, 0x90, 0xC8, 0xD1, 0x24, 0x6D, 0xE0, 0xF1, - 0x00, 0xCA, 0x17, 0x27, 0x68, 0x10, 0x15, 0x88, 0xD2, 0x72, 0x10, 0xC0, 0x54, 0x45, 0x65, 0x57, - 0xAD, 0xCC, 0xD5, 0x45, 0xAC, 0xC4, 0x1C, 0x80, 0xFE, 0x79, 0x9D, 0xE4, 0x60, 0x40, 0x7D, 0x18, - 0xE3, 0xD1, 0x9B, 0xFF, 0x13, 0x7E, 0x9A, 0x32, 0x3E, 0x71, 0x71, 0xDC, 0x97, 0x11, 0x06, 0x1A, - 0x3B, 0x67, 0x66, 0xBF, 0xB9, 0xDF, 0x88, 0xF4, 0x8C, 0x50, 0xB0, 0xDB, 0x45, 0x98, 0xFB, 0xFF, - 0xF7, 0xC0, 0x00, 0x00, 0x01, 0x34, 0x5B, 0xC4, 0xC2, 0x50, 0x34, 0x07, 0x81, 0x33, 0xE1, 0x8C, - 0x11, 0x0B, 0x19, 0x2A, 0x5D, 0xED, 0x92, 0xB7, 0xC8, 0x21, 0x4C, 0x45, 0x76, 0xAD, 0x68, 0x64, - 0x7F, 0xFE, 0xA1, 0x0E, 0x36, 0x65, 0xD7, 0xE7, 0xB3, 0xDB, 0xE8, 0xDA, 0x44, 0x3D, 0x71, 0x77, - 0x19, 0x14, 0x63, 0xEB, 0x00, 0x58, 0x73, 0xBE, 0x62, 0xF2, 0xA9, 0x9F, 0x07, 0xA6, 0xCF, 0x1C, - 0x18, 0xB0, 0x76, 0x67, 0x34, 0x71, 0xE6, 0x96, 0x66, 0x3F, 0x3B, 0x22, 0xA9, 0xBD, 0xCD, 0x47, - 0x26, 0x65, 0x19, 0xBC, 0x8E, 0x69, 0x52, 0x00, 0x09, 0x5C, 0x7D, 0x6A, 0x31, 0x8A, 0x83, 0x06, - 0x1F, 0x29, 0x07, 0x06, 0xC8, 0xA3, 0x23, 0xA1, 0x82, 0xE3, 0x03, 0x04, 0x84, 0x03, 0x44, 0xA7, - 0x67, 0xE1, 0x46, 0x9D, 0x55, 0x03, 0x29, 0x80, 0xF3, 0x9F, 0xC0, 0xB0, 0x19, 0xA9, 0x12, 0x0B, - 0xF6, 0xB2, 0x49, 0x94, 0x00, 0x43, 0x7C, 0xAA, 0x08, 0x0C, 0x40, 0x1B, 0xBB, 0x3B, 0x19, 0x7F, - 0x34, 0xA6, 0xE5, 0x9F, 0x16, 0x7A, 0xD5, 0xB8, 0x9D, 0x10, 0x24, 0x00, 0xDB, 0x48, 0xFE, 0x55, - 0x61, 0x7F, 0x48, 0xE8, 0x20, 0x9B, 0x3F, 0xFF, 0xF0, 0xFF, 0xE1, 0x83, 0xF7, 0x72, 0xFF, 0xAE, - 0x78, 0xB1, 0xF4, 0xE2, 0xA8, 0x5D, 0x1D, 0x64, 0x88, 0xE4, 0x9E, 0xC5, 0x56, 0x6D, 0x66, 0xFF, - 0xFD, 0x3F, 0x4F, 0xEE, 0xFA, 0x5F, 0xF7, 0xFF, 0xD4, 0x20, 0x0A, 0x8E, 0x4A, 0x38, 0x29, 0x8F, - 0x81, 0xEC, 0xF1, 0xAE, 0xC7, 0xD6, 0x24, 0xE3, 0x80, 0x83, 0x4F, 0x44, 0xFA, 0x68, 0xB7, 0x2C, - 0x89, 0xD7, 0xFE, 0x49, 0xAF, 0x13, 0x9E, 0x09, 0x5C, 0x3A, 0x2A, 0xFD, 0x27, 0x47, 0x84, 0x54, - 0x41, 0xA9, 0x22, 0xB7, 0x02, 0x0C, 0xD1, 0xDE, 0x6A, 0xBC, 0x9A, 0x98, 0x11, 0x36, 0xF0, 0xEB, - 0xC2, 0xEB, 0x73, 0xD5, 0x80, 0x00, 0x00, 0x12, 0x4E, 0x3C, 0x4A, 0x2A, 0x61, 0x47, 0xA6, 0x90, - 0x12, 0x12, 0x1C, 0x22, 0x13, 0x36, 0x08, 0x20, 0x0F, 0x00, 0x24, 0x88, 0xCB, 0x06, 0x4D, 0x70, - 0x18, 0xE5, 0xD4, 0x80, 0xC3, 0x26, 0x06, 0x40, 0x6E, 0xEB, 0xC6, 0x7B, 0xDE, 0x01, 0x4C, 0x40, - 0x10, 0x80, 0x41, 0x95, 0x16, 0xA6, 0x44, 0xC0, 0x10, 0xD0, 0x24, 0x8B, 0x73, 0x41, 0x1C, 0xC3, - 0x2D, 0x65, 0xED, 0x28, 0x40, 0x0E, 0xFF, 0xFB, 0x92, 0x64, 0xDF, 0x04, 0x83, 0xC9, 0x33, 0xCB, - 0xD3, 0x6F, 0x2C, 0x40, 0x32, 0xE0, 0x69, 0xBA, 0x04, 0x63, 0x00, 0x12, 0x9C, 0xCF, 0x1C, 0x2E, - 0x61, 0x33, 0x10, 0xE9, 0x85, 0xE7, 0xDC, 0x03, 0x08, 0x1A, 0x2A, 0xC1, 0x91, 0x39, 0x40, 0x9B, - 0xC6, 0xE2, 0x9F, 0x23, 0x4A, 0x21, 0x4C, 0x62, 0x1B, 0x62, 0x12, 0xB7, 0x7E, 0x8D, 0x88, 0xBF, - 0xEA, 0xF4, 0xBA, 0x0D, 0x09, 0xAE, 0x5E, 0x9E, 0x5F, 0x82, 0xD8, 0xA6, 0xB2, 0x41, 0x8B, 0x8B, - 0x85, 0xE6, 0x7F, 0xD0, 0xE2, 0x6F, 0xC6, 0x24, 0xA5, 0x06, 0xD9, 0x10, 0xF8, 0x23, 0x77, 0x8A, - 0xD8, 0xCB, 0x3B, 0xFE, 0x85, 0x7F, 0xCD, 0xAE, 0xB2, 0x77, 0xA4, 0xFD, 0xDD, 0xEC, 0xAF, 0xD5, - 0x80, 0x00, 0x18, 0x17, 0x34, 0x41, 0x31, 0xC6, 0xC2, 0x77, 0xAE, 0x4B, 0xF2, 0x08, 0x48, 0xAD, - 0xDF, 0xF7, 0xE1, 0x03, 0x22, 0x14, 0x2B, 0x3D, 0xBC, 0xBD, 0xEE, 0x5F, 0xDB, 0xA4, 0x02, 0xED, - 0x26, 0xA2, 0xE1, 0xE4, 0x39, 0x36, 0xA0, 0x76, 0xB7, 0x7A, 0x8B, 0x6F, 0x4D, 0x3B, 0x01, 0x42, - 0x61, 0x8D, 0x66, 0x46, 0x21, 0x0D, 0x0C, 0x07, 0x0C, 0x4E, 0x2C, 0x32, 0x54, 0x1C, 0xC4, 0x42, - 0x73, 0x3D, 0x85, 0xCC, 0x60, 0x32, 0x36, 0x31, 0x74, 0xC9, 0x07, 0x63, 0x1C, 0xA6, 0x0C, 0x06, - 0x0C, 0x34, 0x93, 0x10, 0xC3, 0x42, 0x80, 0x70, 0xFC, 0x0A, 0x48, 0x2F, 0x73, 0x18, 0x35, 0xE0, - 0x20, 0x48, 0xC2, 0x35, 0x05, 0xD1, 0x59, 0x89, 0x80, 0x00, 0x62, 0x52, 0xA4, 0xBE, 0x74, 0x9C, - 0xE7, 0xB8, 0x69, 0x97, 0xB5, 0xF1, 0xA3, 0x7E, 0x5C, 0xA6, 0x08, 0xC3, 0x96, 0x6C, 0x8D, 0xBA, - 0xDF, 0x6B, 0x50, 0x5A, 0xE5, 0x58, 0x27, 0xA9, 0xC7, 0x9D, 0x69, 0x4F, 0xC8, 0x8C, 0x4D, 0xE6, - 0xB9, 0xC8, 0xFF, 0x43, 0xD7, 0xFD, 0x6A, 0xDB, 0x3A, 0x15, 0x04, 0x0A, 0xCE, 0xCD, 0x8C, 0x70, - 0x80, 0x81, 0xCF, 0xD3, 0x90, 0x6F, 0x23, 0x56, 0xC9, 0xB4, 0x52, 0xCC, 0x91, 0x3F, 0xFD, 0xB9, - 0x6D, 0x0A, 0xA4, 0x94, 0x01, 0x22, 0x02, 0x24, 0x92, 0x41, 0x0A, 0x30, 0xF1, 0x51, 0xCE, 0x1C, - 0xC3, 0x97, 0x70, 0xC0, 0x83, 0xE8, 0xFD, 0xB9, 0x45, 0xBC, 0xCC, 0x85, 0x6D, 0x2B, 0x70, 0xE1, - 0xE8, 0x5A, 0xEC, 0x10, 0xB4, 0x34, 0x59, 0x66, 0x90, 0x2C, 0xC5, 0x4E, 0x38, 0x32, 0x06, 0x0C, - 0x08, 0xCC, 0x07, 0xC5, 0x54, 0xF2, 0x65, 0xAB, 0x5E, 0x83, 0x8A, 0x2A, 0xE1, 0x45, 0x80, 0x80, - 0x00, 0x04, 0x80, 0x03, 0x49, 0x28, 0xEC, 0xBF, 0xCC, 0xFC, 0xB4, 0xC9, 0x63, 0x19, 0x21, 0x38, - 0x20, 0xA8, 0x1F, 0x21, 0x6B, 0xE4, 0xC6, 0x72, 0xA1, 0x0A, 0xB4, 0x33, 0xEC, 0xE1, 0xD5, 0x6C, - 0x6E, 0xC6, 0x17, 0xA0, 0x26, 0x4F, 0x9F, 0x04, 0xD1, 0x6C, 0xE9, 0x4C, 0xFD, 0xB7, 0x57, 0x7E, - 0x9C, 0xAE, 0x59, 0xF8, 0xF3, 0x93, 0x56, 0xFE, 0x47, 0x13, 0x28, 0xFB, 0x78, 0x8F, 0xFD, 0x7C, - 0xD1, 0xF0, 0x8C, 0x7C, 0xF4, 0x11, 0xC6, 0xD5, 0xFF, 0xFB, 0x92, 0x64, 0xE0, 0x06, 0x04, 0x3F, - 0x30, 0xC9, 0x3B, 0x7A, 0x53, 0xD0, 0x2A, 0x64, 0x8A, 0x39, 0x04, 0x02, 0xA5, 0x90, 0xF8, 0xBD, - 0x24, 0x6E, 0x65, 0x4F, 0x40, 0xEE, 0x00, 0xEA, 0x74, 0x50, 0x88, 0x06, 0x15, 0xB1, 0x97, 0xD5, - 0xCC, 0x1C, 0x2C, 0x04, 0xC8, 0x69, 0x34, 0x47, 0x09, 0x33, 0xAE, 0xDE, 0xB0, 0x8D, 0x6C, 0xD0, - 0x96, 0xA4, 0xBD, 0x0A, 0xA7, 0x67, 0x2A, 0xC4, 0x31, 0x7F, 0xFA, 0x7B, 0xEA, 0xC0, 0x00, 0x00, - 0x0B, 0x1A, 0x10, 0x5A, 0xDA, 0x40, 0x46, 0x15, 0x70, 0xBA, 0xDB, 0xFF, 0x7D, 0xFF, 0x2D, 0xAB, - 0x89, 0xD8, 0x92, 0x40, 0xA1, 0xA6, 0xFF, 0xDA, 0xCF, 0xEF, 0x1F, 0x20, 0x54, 0x59, 0x91, 0x50, - 0x9D, 0x4A, 0xFF, 0x5B, 0xDA, 0x48, 0xBB, 0xA0, 0x90, 0x30, 0xC7, 0x20, 0x3C, 0xD4, 0x68, 0x34, - 0xD4, 0x41, 0x04, 0xC5, 0x52, 0x38, 0xD1, 0x68, 0x54, 0xE7, 0x6D, 0xD0, 0xE9, 0x90, 0x94, 0xCD, - 0xF1, 0x84, 0xC4, 0xD1, 0x5C, 0xE1, 0x25, 0x0C, 0xC6, 0x62, 0x24, 0xC0, 0x52, 0x68, 0xD9, 0x32, - 0x28, 0xCE, 0xC3, 0xC8, 0xC4, 0x81, 0x30, 0xC7, 0x74, 0xC8, 0x2F, 0x40, 0xF2, 0x41, 0x4D, 0x01, - 0xE3, 0xC1, 0x54, 0xC7, 0x5D, 0xB3, 0x4F, 0x0E, 0x02, 0x16, 0x6A, 0xA2, 0x4E, 0xD9, 0x32, 0x14, - 0x22, 0x5D, 0x05, 0x60, 0xC0, 0x42, 0xC5, 0x48, 0x17, 0x7C, 0x2A, 0x40, 0x04, 0x70, 0x23, 0x10, - 0xE8, 0x14, 0x76, 0x01, 0x38, 0x2F, 0xA1, 0x31, 0x18, 0x88, 0xE9, 0x33, 0x80, 0x92, 0xEA, 0xD6, - 0x32, 0x23, 0xC1, 0xC3, 0x8C, 0x98, 0x66, 0xB4, 0x60, 0x82, 0xA9, 0x88, 0x2B, 0x2B, 0xF2, 0xCF, - 0x3A, 0xE8, 0x96, 0x32, 0x22, 0x5C, 0x65, 0xF8, 0xB6, 0xCD, 0xD4, 0x49, 0xE2, 0xD3, 0x64, 0x3D, - 0x3F, 0xB9, 0x0F, 0xCD, 0xAA, 0xA6, 0xF8, 0x9D, 0xB1, 0xE2, 0x3D, 0x4C, 0xBA, 0x19, 0xEF, 0xFB, - 0x7A, 0xD6, 0x30, 0x54, 0x96, 0x89, 0x5A, 0x9D, 0x2A, 0x27, 0x78, 0xE8, 0x81, 0x65, 0x48, 0xC9, - 0xAE, 0x20, 0x1E, 0x80, 0xD9, 0x25, 0x29, 0x8B, 0xD7, 0x32, 0xB7, 0x80, 0x7F, 0xD7, 0xFB, 0x1F, - 0x00, 0x00, 0x90, 0xE6, 0x18, 0x87, 0xC2, 0xB6, 0xC7, 0x03, 0x82, 0x78, 0x9C, 0xE5, 0xA0, 0x2D, - 0xBF, 0xE4, 0x40, 0xB0, 0x56, 0x88, 0x62, 0xBB, 0x6F, 0xC9, 0x82, 0x02, 0x91, 0xC3, 0x5E, 0x88, - 0x68, 0x54, 0x40, 0x85, 0xB9, 0x62, 0x73, 0x1D, 0x66, 0xD9, 0x67, 0xFF, 0xDA, 0xB1, 0xCD, 0xBA, - 0xE9, 0x45, 0x35, 0x14, 0x0B, 0xB1, 0x88, 0x5A, 0xB6, 0x3C, 0x78, 0xB0, 0x41, 0xF0, 0x19, 0xD1, - 0xCB, 0x8A, 0x21, 0x80, 0x00, 0x00, 0x00, 0x59, 0x36, 0xFA, 0xB9, 0x29, 0x30, 0xB3, 0xF6, 0x5E, - 0x83, 0x40, 0x47, 0x44, 0x63, 0xC2, 0xEA, 0x0E, 0xCB, 0x61, 0x3F, 0xF0, 0xBC, 0x24, 0xA1, 0x03, - 0x78, 0xD5, 0xB0, 0x77, 0x8B, 0xA8, 0x10, 0x65, 0x1F, 0x6A, 0xF0, 0xC2, 0x83, 0x24, 0x0F, 0x65, - 0xC4, 0x03, 0xD4, 0xE5, 0x0A, 0x0E, 0x83, 0x62, 0x08, 0xD4, 0xFF, 0xFB, 0x92, 0x64, 0xE4, 0x00, - 0x43, 0x58, 0x32, 0xD0, 0x6B, 0x0C, 0x3C, 0xBC, 0x28, 0xC0, 0x2A, 0x29, 0x0C, 0x42, 0x01, 0x97, - 0x44, 0xCB, 0x14, 0x0E, 0xE9, 0xEF, 0x41, 0x0B, 0x89, 0x25, 0xDC, 0xC4, 0x8D, 0xC8, 0xB8, 0xE4, - 0xA2, 0x15, 0x09, 0xE8, 0x8C, 0xC5, 0xF4, 0xFD, 0x06, 0x34, 0x74, 0x73, 0x54, 0xB9, 0x91, 0x00, - 0xE9, 0xD9, 0x99, 0xDF, 0xBF, 0x31, 0x56, 0x5F, 0x80, 0x87, 0x85, 0x27, 0xCE, 0xE1, 0x92, 0xE1, - 0x84, 0x56, 0xEF, 0xFD, 0x7F, 0x23, 0xFF, 0xE4, 0x3F, 0xFF, 0xB3, 0xDB, 0x00, 0x00, 0x00, 0x40, - 0x04, 0x38, 0x25, 0xA1, 0x11, 0x7A, 0x0A, 0x4D, 0x9D, 0x82, 0x2B, 0xF1, 0x54, 0x2A, 0x8C, 0x34, - 0xEA, 0xE9, 0x7B, 0xF7, 0xFF, 0x57, 0x21, 0xCA, 0x9D, 0xDE, 0xCF, 0xF9, 0xDF, 0x3D, 0x0C, 0x58, - 0x70, 0x8B, 0x82, 0x82, 0x75, 0xB5, 0xD2, 0x2E, 0x7C, 0xF9, 0xAC, 0x5F, 0x03, 0xAA, 0x54, 0xC0, - 0x00, 0x03, 0x7B, 0xD2, 0x04, 0x15, 0x3C, 0x85, 0xF1, 0xA6, 0xE3, 0x26, 0x0C, 0x31, 0xF3, 0x03, - 0xD8, 0xC5, 0x32, 0x61, 0x73, 0x1F, 0x8A, 0x32, 0x24, 0x73, 0x36, 0xAB, 0x08, 0x97, 0x30, 0xF0, - 0x53, 0x12, 0x33, 0x38, 0x9F, 0x23, 0x2F, 0x18, 0x32, 0x88, 0x93, 0x85, 0xB3, 0x29, 0xA1, 0x61, - 0x4B, 0xE2, 0xC2, 0xCC, 0x60, 0x01, 0xA0, 0xA2, 0x99, 0x22, 0x50, 0x23, 0x23, 0x57, 0x03, 0xA9, - 0x99, 0x01, 0x34, 0xD6, 0x20, 0xA1, 0xAF, 0xFA, 0x3B, 0x21, 0x25, 0x0D, 0x56, 0x05, 0xB1, 0x2E, - 0xD2, 0xFC, 0xAC, 0x3C, 0x59, 0xF6, 0x42, 0x4B, 0xA6, 0xFC, 0x88, 0x85, 0x05, 0x04, 0xD1, 0x21, - 0x34, 0x8E, 0x21, 0x87, 0x34, 0xD2, 0xE2, 0x06, 0x46, 0x16, 0x0C, 0x7E, 0xAB, 0xBD, 0xCE, 0xE8, - 0x63, 0xF8, 0xF8, 0x4C, 0x2A, 0x48, 0x0E, 0x13, 0xC6, 0x48, 0x84, 0xEA, 0xFF, 0xFD, 0xFE, 0xF0, - 0x23, 0xBE, 0x00, 0xB1, 0x9F, 0xED, 0xD3, 0xD1, 0xD5, 0x80, 0x00, 0x00, 0xD4, 0x2C, 0x43, 0x22, - 0x48, 0x96, 0xAA, 0x0B, 0x22, 0x90, 0x6B, 0x11, 0xFA, 0xDE, 0xA4, 0xAC, 0xC3, 0x43, 0x08, 0xFF, - 0x14, 0xC3, 0xB3, 0x4C, 0xF9, 0xD7, 0x25, 0xCA, 0x58, 0x95, 0x5F, 0x5F, 0x6B, 0x8C, 0x03, 0xA2, - 0x59, 0xEE, 0xB6, 0xAD, 0xED, 0xB4, 0x51, 0xCE, 0xA2, 0x08, 0x07, 0x41, 0x64, 0x87, 0x47, 0xA8, - 0x40, 0x0E, 0x3D, 0x94, 0x2A, 0x00, 0x02, 0x12, 0x73, 0x2A, 0x61, 0x12, 0x00, 0x73, 0x40, 0x28, - 0xC8, 0x12, 0x16, 0x62, 0xE6, 0x87, 0x60, 0xF4, 0x6F, 0xE2, 0x66, 0x10, 0xD6, 0x60, 0x67, 0xE6, - 0x3D, 0x0C, 0x63, 0x87, 0x86, 0x12, 0x32, 0x02, 0x1E, 0x34, 0x4D, 0xD2, 0xFB, 0x9A, 0x90, 0x70, - 0x01, 0x40, 0x99, 0xA0, 0x7C, 0x3E, 0x8C, 0xAF, 0x02, 0x38, 0xA8, 0x21, 0x60, 0x83, 0x4C, 0xA7, - 0x6A, 0x8B, 0x0E, 0x2C, 0x06, 0x68, 0xC2, 0x90, 0x4E, 0xBC, 0x17, 0x33, 0x58, 0x22, 0xAC, 0x6D, - 0xF0, 0x8C, 0xB0, 0xA6, 0xEF, 0x46, 0xCC, 0x19, 0x43, 0x5D, 0xBA, 0x80, 0xFF, 0xFB, 0x92, 0x64, - 0xDA, 0x84, 0x03, 0x27, 0x21, 0x4C, 0x53, 0x58, 0x61, 0xD0, 0x33, 0xC1, 0x4A, 0x1D, 0x2C, 0x23, - 0x00, 0x91, 0x28, 0xC3, 0x20, 0x4D, 0xE5, 0x4F, 0x50, 0xED, 0x0D, 0x68, 0x24, 0x50, 0x0E, 0x4E, - 0x42, 0x86, 0xDE, 0xBD, 0xD7, 0xFE, 0x8D, 0x47, 0x32, 0x22, 0x84, 0x3A, 0xAC, 0xB9, 0xD2, 0x2F, - 0xBF, 0xE5, 0x15, 0x51, 0x50, 0x90, 0xB3, 0x89, 0xB5, 0x0A, 0xFF, 0x86, 0x3F, 0xAB, 0x7D, 0x69, - 0xF3, 0xAC, 0x7A, 0xD4, 0x2C, 0xFF, 0xD3, 0xBB, 0xEB, 0xC8, 0x00, 0x00, 0x00, 0xAD, 0xDB, 0x88, - 0xA4, 0xC7, 0x22, 0xB8, 0x1E, 0xA3, 0x96, 0xB2, 0x43, 0xFC, 0x3F, 0x57, 0x14, 0x96, 0x16, 0x02, - 0xB6, 0xFE, 0xD1, 0x00, 0x7C, 0x72, 0xAA, 0xF5, 0x76, 0xDE, 0x25, 0x83, 0x1B, 0x94, 0xE5, 0x18, - 0x5D, 0x40, 0xA0, 0x18, 0xA9, 0x04, 0xEC, 0x3E, 0x0E, 0x8E, 0x4A, 0x59, 0x52, 0x9F, 0x75, 0xA8, - 0x49, 0xE1, 0x62, 0xAB, 0x43, 0x96, 0xEA, 0xD7, 0x00, 0x01, 0x37, 0x58, 0x12, 0x8A, 0x98, 0x28, - 0x51, 0xAE, 0xAA, 0x99, 0x68, 0x30, 0x38, 0x24, 0xD1, 0x89, 0x8C, 0x42, 0x90, 0x70, 0x88, 0xCC, - 0x41, 0xC0, 0xC1, 0x86, 0x26, 0x36, 0xB2, 0x84, 0xA6, 0x0C, 0xB0, 0x10, 0xF4, 0xE6, 0x0C, 0xA0, - 0x44, 0x39, 0x04, 0x10, 0x50, 0x1D, 0x5E, 0xB1, 0x5F, 0xC9, 0x01, 0xD7, 0x2D, 0x6E, 0x58, 0xCD, - 0xC9, 0xBB, 0x85, 0x1B, 0x86, 0xCE, 0x64, 0xB1, 0x94, 0xB2, 0x62, 0xEB, 0xF9, 0x93, 0x22, 0xAB, - 0x79, 0x8D, 0x3B, 0x31, 0x89, 0xE0, 0xA3, 0x8D, 0x75, 0xE4, 0xA5, 0x41, 0xA6, 0xEA, 0xAD, 0x92, - 0x18, 0x94, 0xBC, 0xBD, 0xD8, 0xA0, 0xBC, 0x9D, 0x10, 0xB9, 0x1D, 0x4F, 0x38, 0x75, 0xF3, 0xD5, - 0x35, 0xDF, 0x92, 0x0F, 0xB9, 0xC4, 0x66, 0x54, 0x87, 0x42, 0xF9, 0xD5, 0x76, 0xE8, 0x46, 0x75, - 0xA3, 0xEA, 0x43, 0x54, 0xCE, 0xA6, 0x11, 0x42, 0x7D, 0x7F, 0x4F, 0x03, 0x22, 0x28, 0x12, 0xEE, - 0x21, 0x86, 0x96, 0x2D, 0x84, 0xDA, 0x90, 0x40, 0xD9, 0x7E, 0x25, 0x06, 0x46, 0xBF, 0x3E, 0x2C, - 0xD6, 0xE8, 0xA4, 0x96, 0x9F, 0xF4, 0x93, 0x65, 0x0F, 0x06, 0xC2, 0x0C, 0xCC, 0xDA, 0xE7, 0x2D, - 0x84, 0xD0, 0x95, 0xDD, 0x10, 0xAC, 0x45, 0x2E, 0x74, 0xFD, 0x63, 0xC5, 0x6C, 0x81, 0x65, 0x43, - 0xE8, 0x0D, 0xD5, 0x5C, 0x9D, 0x00, 0x01, 0x69, 0xA5, 0x1F, 0x30, 0xE0, 0x6C, 0xD2, 0x0F, 0x43, - 0x2B, 0x87, 0x40, 0xA3, 0x83, 0x16, 0xAE, 0x8C, 0x36, 0xAB, 0x01, 0x38, 0x0C, 0x0B, 0x0E, 0x31, - 0x99, 0x2C, 0x6A, 0xDA, 0x01, 0x0C, 0x99, 0xC5, 0x54, 0x71, 0x14, 0xE9, 0xF0, 0x25, 0x26, 0x41, - 0x0D, 0x85, 0x06, 0x86, 0x48, 0x26, 0x98, 0x64, 0x54, 0xFB, 0xA0, 0x40, 0x02, 0x08, 0x36, 0xF8, - 0x91, 0x3F, 0x03, 0x80, 0xA3, 0xAB, 0x84, 0x1B, 0x0B, 0xA8, 0xA6, 0x68, 0x00, 0x5B, 0xEA, 0x62, - 0x5B, 0x67, 0x91, 0x93, 0x8C, 0x2C, 0x5A, 0xE5, 0x59, 0x79, 0x47, 0xDA, 0xF4, 0x17, 0xFF, 0xFB, - 0x92, 0x64, 0xEA, 0x86, 0x64, 0x00, 0x30, 0xC9, 0x1B, 0x78, 0x2B, 0xD0, 0x3E, 0xE1, 0x49, 0xBA, - 0x08, 0xC9, 0x04, 0x10, 0x88, 0xC9, 0x25, 0x4D, 0xE0, 0xF1, 0x00, 0xE2, 0x06, 0x26, 0xF4, 0x17, - 0x98, 0x48, 0x46, 0xCE, 0x8B, 0x86, 0xDE, 0xAF, 0x53, 0x06, 0x52, 0xD3, 0xA9, 0x5B, 0x88, 0x9D, - 0xEB, 0x49, 0xAA, 0xDE, 0x03, 0xB8, 0x19, 0x31, 0x49, 0x8A, 0x67, 0x5C, 0xA5, 0x92, 0xAB, 0x26, - 0x56, 0x8F, 0x8F, 0xA6, 0x9F, 0xDD, 0xB9, 0x6B, 0xA3, 0xA6, 0x41, 0x79, 0x66, 0x39, 0x33, 0xDE, - 0x29, 0x75, 0xF4, 0xFA, 0x71, 0x5E, 0x2D, 0xE3, 0x13, 0x51, 0x7B, 0x63, 0xEC, 0xFF, 0xED, 0x50, - 0x84, 0x00, 0xA4, 0x9B, 0x82, 0xD0, 0xF4, 0x1B, 0x35, 0xDC, 0x9A, 0x08, 0x5C, 0xF7, 0xBD, 0x81, - 0x41, 0x87, 0x31, 0xCD, 0xFA, 0x5F, 0x17, 0x50, 0xC5, 0x73, 0x7E, 0x2E, 0xFF, 0xB6, 0xA3, 0x94, - 0xC4, 0x6D, 0x24, 0x6D, 0x6E, 0x16, 0x42, 0x56, 0x69, 0x7A, 0xF7, 0x97, 0xB9, 0xB2, 0xD2, 0xA4, - 0x62, 0x97, 0xA1, 0x0A, 0x0F, 0xB4, 0xD0, 0x00, 0x10, 0x54, 0x15, 0xA3, 0x22, 0x30, 0xC6, 0xB5, - 0x80, 0xB3, 0x73, 0x22, 0x1C, 0xD6, 0x87, 0x3E, 0xD4, 0x4D, 0x09, 0x63, 0x25, 0xA4, 0x44, 0x68, - 0xCC, 0x99, 0x4C, 0x83, 0x02, 0xD9, 0x83, 0x9E, 0x7D, 0xC6, 0xB4, 0x68, 0x63, 0x13, 0x0A, 0x8C, - 0x4C, 0x4A, 0x50, 0x3B, 0x45, 0xEA, 0x0E, 0x38, 0xBA, 0x60, 0x85, 0x4A, 0xA5, 0x16, 0x75, 0x24, - 0xCB, 0x80, 0xF5, 0x0C, 0x39, 0x11, 0x4A, 0xA1, 0x3A, 0x31, 0x55, 0xB1, 0xCB, 0x00, 0xF0, 0x4C, - 0x6D, 0x26, 0xCC, 0x3B, 0xD8, 0xC3, 0x90, 0x58, 0x90, 0x85, 0xE9, 0x22, 0x97, 0x88, 0x0C, 0x38, - 0xDA, 0x3C, 0xA0, 0x71, 0x73, 0xB5, 0x06, 0xA2, 0x5B, 0xE2, 0x1E, 0x28, 0x55, 0x81, 0x31, 0x2B, - 0xFF, 0xEF, 0xD1, 0xEA, 0xA3, 0x6E, 0x1A, 0x63, 0x0D, 0x2E, 0x44, 0xA8, 0x7E, 0x40, 0x00, 0x40, - 0x03, 0x92, 0x4A, 0x38, 0x0C, 0x5A, 0xA4, 0x96, 0x96, 0x33, 0x63, 0xA9, 0xE1, 0x70, 0x00, 0x0B, - 0xDD, 0xFF, 0x4F, 0x7C, 0xC1, 0xF4, 0x8F, 0x73, 0x62, 0x82, 0x90, 0x31, 0x00, 0xDB, 0xD2, 0x7D, - 0x2A, 0x22, 0x69, 0xF6, 0xFD, 0x04, 0x9C, 0xD3, 0x55, 0xA7, 0x9B, 0x8C, 0x2A, 0x42, 0xD6, 0xDF, - 0x62, 0x55, 0x80, 0x00, 0x00, 0x00, 0x9A, 0xB7, 0x7B, 0xB0, 0x63, 0x11, 0x04, 0xF6, 0x40, 0x00, - 0x84, 0x48, 0x51, 0x79, 0xC0, 0x8C, 0xAB, 0x40, 0xAC, 0x8C, 0x09, 0x73, 0x34, 0x01, 0x4D, 0x04, - 0x43, 0x09, 0x4C, 0x1C, 0x83, 0x4A, 0x18, 0x24, 0x2C, 0xC1, 0x92, 0x30, 0x41, 0x59, 0xF3, 0x90, - 0x22, 0xC1, 0x5A, 0xE9, 0x9C, 0xF6, 0x31, 0xDE, 0x28, 0xCE, 0xF4, 0xFB, 0x9B, 0x2C, 0x55, 0xDE, - 0xD0, 0xE0, 0x5F, 0x2B, 0x9A, 0xA4, 0x55, 0xAF, 0x38, 0x41, 0xD4, 0x04, 0x40, 0xD2, 0x1C, 0x28, - 0x35, 0x24, 0x2F, 0xE2, 0xC2, 0x6C, 0x5B, 0xF8, 0x44, 0x5D, 0x24, 0x6B, 0x9E, 0xA1, 0xA1, 0x86, - 0xFF, 0xFB, 0x92, 0x64, 0xEB, 0x8C, 0x04, 0xB5, 0x32, 0x47, 0x13, 0x99, 0x4C, 0xB0, 0x37, 0x01, - 0x59, 0xC7, 0x00, 0x69, 0x02, 0x8E, 0xC4, 0xC3, 0x26, 0x6D, 0x3C, 0x52, 0xC0, 0xD2, 0x04, 0xA8, - 0x68, 0x30, 0x8C, 0x8A, 0xDB, 0x61, 0x74, 0x0E, 0xA3, 0xC4, 0x0F, 0xA4, 0xF1, 0x45, 0x25, 0xEB, - 0x99, 0x59, 0x30, 0x19, 0x7B, 0x2B, 0xB0, 0x24, 0x95, 0x21, 0x11, 0x47, 0x0A, 0xEB, 0x63, 0xC7, - 0xFF, 0xC7, 0x53, 0x43, 0xDF, 0x52, 0xE0, 0x09, 0x01, 0x37, 0x2E, 0x17, 0x2D, 0x19, 0x19, 0xF2, - 0x77, 0xDB, 0xAE, 0x85, 0x3B, 0x91, 0xD4, 0xD6, 0xE8, 0xA1, 0x3E, 0x53, 0xB7, 0x7F, 0x98, 0x45, - 0x4A, 0x9C, 0x85, 0x23, 0x75, 0xBD, 0xE6, 0x1A, 0x01, 0x28, 0x2E, 0x27, 0x29, 0xBC, 0xD5, 0x99, - 0x34, 0xA4, 0xE5, 0x24, 0x18, 0xE1, 0x75, 0x00, 0x14, 0xA6, 0xAA, 0xDA, 0x51, 0x85, 0x5A, 0x95, - 0x94, 0x33, 0x3E, 0x9B, 0xE2, 0xE0, 0x00, 0x42, 0x4E, 0x5D, 0x91, 0x02, 0x44, 0x81, 0xD0, 0x21, - 0x9A, 0x80, 0x80, 0x63, 0x52, 0x32, 0x30, 0x6C, 0xE3, 0x3C, 0x21, 0x37, 0xA1, 0x71, 0x92, 0xE3, - 0x07, 0x34, 0x0B, 0xA7, 0x05, 0x97, 0x8D, 0x84, 0x14, 0xDC, 0xF0, 0x48, 0x9B, 0xCC, 0x54, 0x54, - 0x60, 0x82, 0x5A, 0x07, 0x1D, 0xF7, 0x53, 0x31, 0x4E, 0xA8, 0x33, 0x9E, 0xDC, 0x96, 0x74, 0x93, - 0x88, 0x09, 0x45, 0xB5, 0x43, 0x45, 0x30, 0xD8, 0xA4, 0x10, 0x09, 0xB0, 0x54, 0x4D, 0xF3, 0x73, - 0x4C, 0xFA, 0xCE, 0xDC, 0xD3, 0x35, 0xC9, 0xB9, 0xA5, 0x70, 0x5C, 0x4C, 0xEA, 0x38, 0xF1, 0xD2, - 0x8B, 0xCB, 0xB4, 0x18, 0xA0, 0x67, 0xFA, 0x20, 0xEA, 0x60, 0x45, 0x90, 0xAC, 0x1B, 0xA0, 0x8E, - 0x5C, 0xC7, 0x1F, 0x87, 0xB3, 0x0E, 0xA8, 0xFE, 0x96, 0x95, 0xBA, 0xB5, 0xB3, 0xAD, 0x7A, 0x52, - 0x2D, 0xDD, 0xA9, 0x2D, 0x24, 0xDD, 0x5F, 0xD5, 0xB3, 0xEA, 0x48, 0x40, 0x00, 0x09, 0x20, 0x13, - 0x4E, 0x40, 0x50, 0x55, 0x82, 0xCE, 0x7D, 0x39, 0x15, 0x3F, 0x58, 0x91, 0x42, 0x98, 0x20, 0x54, - 0x5C, 0x3A, 0x0D, 0x05, 0x98, 0xDF, 0x25, 0xC9, 0xBC, 0xC1, 0xF5, 0x15, 0x50, 0x70, 0xC9, 0x67, - 0x55, 0x67, 0xE6, 0x26, 0x07, 0xA6, 0xE5, 0xB9, 0x25, 0xCC, 0xCC, 0x13, 0xA9, 0x75, 0x1B, 0x6B, - 0xDE, 0x29, 0x0E, 0xD0, 0xDE, 0xC8, 0x5D, 0x00, 0x0D, 0x08, 0xD2, 0x3B, 0xA0, 0x9C, 0xD0, 0x6A, - 0x93, 0x3D, 0x02, 0x05, 0x83, 0x26, 0x61, 0x34, 0x1A, 0x9D, 0x18, 0x6C, 0x64, 0x09, 0xB3, 0xC5, - 0xC6, 0x20, 0x25, 0x98, 0xED, 0x32, 0x65, 0x10, 0x80, 0x18, 0x7E, 0x70, 0x33, 0x89, 0xAA, 0x7C, - 0x06, 0x32, 0x34, 0x83, 0x44, 0x84, 0x23, 0x9D, 0x2A, 0x11, 0x40, 0x16, 0x21, 0x0F, 0x4D, 0xD4, - 0x18, 0xD4, 0xB1, 0x09, 0x90, 0x5B, 0x80, 0x8E, 0xC5, 0x07, 0xA1, 0x15, 0x2C, 0xE0, 0x54, 0x10, - 0xB0, 0x11, 0x55, 0xC0, 0x3C, 0x0A, 0x96, 0xAD, 0x35, 0x34, 0x28, 0x11, 0x93, 0xC8, 0x9A, 0x33, - 0x5F, 0x89, 0xFF, 0xFB, 0x92, 0x64, 0xEE, 0x04, 0x04, 0x02, 0x30, 0xCB, 0x53, 0x4F, 0x2C, 0x40, - 0x3F, 0x22, 0x79, 0x87, 0x24, 0xC3, 0x1E, 0x10, 0x94, 0xC3, 0x24, 0x6D, 0xE0, 0x6F, 0x40, 0xF3, - 0x06, 0xE7, 0x74, 0x33, 0x09, 0x42, 0xB3, 0x64, 0x24, 0x91, 0x86, 0x89, 0xEE, 0x12, 0x2B, 0x5A, - 0x00, 0x06, 0x7C, 0xA8, 0x3F, 0x26, 0x24, 0xFC, 0xBB, 0xCF, 0x1D, 0xD0, 0xB3, 0xA9, 0xEA, 0x57, - 0x71, 0xC0, 0x78, 0x36, 0x49, 0x69, 0xEC, 0x3C, 0x10, 0x18, 0x70, 0x9C, 0x26, 0x1D, 0x61, 0x43, - 0x2E, 0x36, 0x9F, 0xA7, 0xBD, 0xFA, 0x40, 0x0B, 0x80, 0x1B, 0x60, 0x45, 0x45, 0xDC, 0x40, 0x47, - 0x9B, 0x76, 0x18, 0x63, 0xC0, 0x86, 0xDB, 0x63, 0x52, 0x36, 0x86, 0x11, 0xF3, 0xDF, 0x4F, 0xD5, - 0x5C, 0xBA, 0x38, 0x28, 0x5C, 0x4B, 0xEF, 0x4B, 0x46, 0xA8, 0x12, 0x1A, 0x9F, 0xFA, 0x6F, 0x8E, - 0x98, 0x63, 0x62, 0x00, 0xE3, 0x50, 0x50, 0x79, 0xC4, 0x18, 0x25, 0x9D, 0xCF, 0x3C, 0x73, 0xC3, - 0x22, 0xEA, 0x56, 0x1B, 0x36, 0xE1, 0xA4, 0x19, 0x30, 0xA8, 0xC4, 0xC5, 0x43, 0x40, 0xC1, 0x20, - 0xD0, 0x14, 0x90, 0x28, 0x60, 0x48, 0x89, 0x9B, 0x84, 0x26, 0x50, 0x0C, 0x36, 0x86, 0x62, 0x46, - 0x18, 0xAC, 0x64, 0x4C, 0x21, 0x31, 0x88, 0xE8, 0xE7, 0x8C, 0x90, 0x31, 0xA0, 0x0C, 0x5F, 0x10, - 0xDE, 0x10, 0xE3, 0xB6, 0x99, 0x40, 0x82, 0x91, 0xB4, 0xBC, 0x90, 0x3A, 0xE8, 0x4A, 0x1D, 0x31, - 0x90, 0x40, 0x2E, 0x84, 0x67, 0x6D, 0x65, 0x42, 0xDB, 0x9A, 0x8B, 0x30, 0x66, 0x20, 0xEB, 0x44, - 0xDB, 0xA4, 0xBE, 0x72, 0x3D, 0x72, 0x5F, 0x2D, 0x43, 0xAA, 0x11, 0xB5, 0x28, 0x44, 0x17, 0x40, - 0x0A, 0x7F, 0xE0, 0x5C, 0x3B, 0x16, 0xBF, 0xF6, 0xE7, 0x5E, 0xE9, 0x7E, 0x06, 0x32, 0x25, 0x95, - 0x68, 0x4E, 0x1C, 0xBA, 0xA2, 0xC5, 0x9C, 0xB1, 0xFF, 0x47, 0xFF, 0xFF, 0xBF, 0xFF, 0xF5, 0xD6, - 0x00, 0x03, 0x58, 0xAF, 0xC0, 0x8F, 0xAB, 0x6C, 0xAB, 0xF3, 0x16, 0xE1, 0x2D, 0xF5, 0x4B, 0x28, - 0x9C, 0xB7, 0xD6, 0xCF, 0x95, 0x3D, 0xD7, 0xD5, 0xC8, 0xB5, 0xE5, 0x61, 0x43, 0x8D, 0x9E, 0x97, - 0x70, 0x6E, 0xB2, 0x35, 0xB5, 0x67, 0xE3, 0x5F, 0x4A, 0x15, 0x5B, 0x0B, 0xBC, 0x5C, 0x58, 0x04, - 0x23, 0x0D, 0x5F, 0x11, 0x89, 0xCD, 0x28, 0x22, 0x01, 0xAF, 0x21, 0x3C, 0xCA, 0x08, 0x53, 0x32, - 0x81, 0xCC, 0x78, 0x0E, 0x30, 0x38, 0x0C, 0x40, 0xA7, 0x39, 0x91, 0xF8, 0xC1, 0xCA, 0x73, 0x49, - 0x8B, 0x8C, 0x32, 0x46, 0x35, 0xF9, 0xDC, 0xCC, 0x05, 0x53, 0x10, 0x8B, 0x4D, 0x08, 0x3A, 0x13, - 0xF7, 0x18, 0x7C, 0x2C, 0x64, 0xD0, 0xA9, 0x80, 0x85, 0x03, 0x02, 0x31, 0x60, 0x60, 0x10, 0x84, - 0x3A, 0xF0, 0x36, 0x84, 0x27, 0x76, 0x0B, 0xAC, 0x00, 0x70, 0x88, 0x76, 0x47, 0x40, 0x85, 0x92, - 0xA6, 0x91, 0x0C, 0x8B, 0x09, 0xB7, 0x14, 0x32, 0x2C, 0x35, 0x97, 0x1C, 0xB6, 0x6B, 0x9E, 0x5A, - 0xB2, 0x60, 0x25, 0x2A, 0xFF, 0xFB, 0x92, 0x64, 0xEC, 0x8E, 0x84, 0x5A, 0x30, 0xC7, 0x93, 0x99, - 0x3B, 0xD0, 0x3D, 0xC3, 0x69, 0xAD, 0x00, 0x67, 0x1E, 0x0F, 0x64, 0xB1, 0x24, 0x4E, 0x65, 0x0F, - 0x40, 0xE3, 0x0D, 0x64, 0xE4, 0x20, 0x1C, 0xC8, 0x8B, 0x38, 0x03, 0x89, 0x6C, 0x6A, 0x05, 0x21, - 0x8C, 0x3E, 0xA0, 0x0C, 0x91, 0x32, 0xF9, 0x1E, 0x40, 0x5A, 0xEA, 0x3E, 0x4B, 0x6E, 0x76, 0x2F, - 0x27, 0x52, 0xBD, 0x23, 0x8D, 0xD4, 0xB8, 0xB7, 0x2A, 0xAD, 0x13, 0xD7, 0xDA, 0x76, 0x8B, 0x66, - 0xB6, 0x25, 0x8D, 0x53, 0xCF, 0xE2, 0xD0, 0x52, 0x28, 0x7A, 0x9A, 0x13, 0xF1, 0x54, 0x00, 0x8A, - 0x8A, 0x00, 0x00, 0x0D, 0x96, 0xE8, 0xAE, 0x3E, 0x8D, 0xE8, 0xD9, 0x60, 0x47, 0x51, 0xF6, 0xDC, - 0x18, 0xF4, 0xCE, 0xEA, 0xD1, 0x31, 0x71, 0xCA, 0xFE, 0xA3, 0x88, 0x31, 0x01, 0x80, 0x43, 0x46, - 0x2A, 0xA0, 0x65, 0x6B, 0xB8, 0x5F, 0xF6, 0x38, 0x86, 0xE6, 0xBC, 0xAB, 0x21, 0x47, 0x8C, 0x81, - 0x9F, 0xBA, 0x54, 0xC4, 0x50, 0x4A, 0xF3, 0x65, 0x82, 0x84, 0xD4, 0x58, 0x90, 0x20, 0x88, 0x00, - 0x00, 0x04, 0x52, 0x82, 0x0E, 0x6E, 0xC2, 0x22, 0xA0, 0xCF, 0x41, 0x63, 0x53, 0x0B, 0x17, 0x31, - 0x82, 0x33, 0x50, 0xC4, 0x12, 0x41, 0x30, 0x60, 0x43, 0x0C, 0x16, 0x36, 0x20, 0x23, 0x1D, 0x27, - 0x31, 0xC1, 0x53, 0x37, 0x12, 0x3C, 0x23, 0xA8, 0x51, 0x82, 0x8F, 0x02, 0x03, 0xC0, 0x48, 0x0A, - 0x95, 0x01, 0xD2, 0x01, 0x61, 0xC8, 0xE3, 0x4E, 0x73, 0x31, 0xC5, 0xB9, 0x4C, 0x07, 0x50, 0x6E, - 0xD8, 0xE2, 0x2A, 0x90, 0xE7, 0x22, 0x7C, 0x3D, 0x26, 0x71, 0x37, 0x28, 0x0C, 0x8B, 0xAE, 0x9B, - 0x11, 0x38, 0x6D, 0x6E, 0x17, 0xA6, 0xAA, 0xFA, 0x38, 0xFD, 0x39, 0x00, 0x26, 0xEC, 0x5B, 0xF3, - 0x6A, 0x88, 0xE6, 0x77, 0x93, 0xF8, 0x58, 0x8A, 0x45, 0x5E, 0x8D, 0x5F, 0x67, 0xFD, 0x1E, 0xB2, - 0x6F, 0x3E, 0x79, 0xEE, 0x9D, 0xCA, 0xAC, 0x63, 0x80, 0x00, 0x00, 0x10, 0x02, 0x30, 0xBB, 0x88, - 0xE9, 0xBF, 0x4C, 0x8B, 0xA0, 0x84, 0x9D, 0x0E, 0x67, 0xA6, 0xF4, 0x01, 0x05, 0x83, 0xA9, 0x1E, - 0x82, 0xC4, 0xDA, 0x9F, 0xCC, 0x3A, 0xE7, 0x03, 0x1F, 0xF9, 0x85, 0x12, 0x26, 0x43, 0x78, 0xA0, - 0x78, 0x6A, 0xAE, 0x96, 0x39, 0x3B, 0xC2, 0x8F, 0x54, 0x51, 0x8D, 0xA1, 0xCA, 0x4A, 0xAA, 0x84, - 0x00, 0x00, 0x00, 0x08, 0xB6, 0xF8, 0xF4, 0x79, 0xD6, 0x32, 0xF2, 0x90, 0xE2, 0xD0, 0x70, 0x18, - 0x88, 0x20, 0xD1, 0xE0, 0x46, 0xA2, 0x0C, 0x44, 0x31, 0x13, 0x4C, 0x74, 0x25, 0xA6, 0x3F, 0xE6, - 0x6C, 0x1A, 0x6B, 0x63, 0x6A, 0x18, 0x61, 0x23, 0x43, 0x41, 0xCC, 0xB6, 0x50, 0xD3, 0x53, 0xE0, - 0x67, 0x78, 0x8A, 0x71, 0x07, 0xBB, 0x4A, 0x50, 0x29, 0x5A, 0x59, 0x1C, 0x98, 0x14, 0xB0, 0xC9, - 0x99, 0x6F, 0x80, 0xB0, 0xC1, 0x06, 0x8D, 0xB1, 0xD5, 0x76, 0x84, 0xF8, 0xB1, 0x32, 0xED, 0xAA, - 0x47, 0x85, 0x6D, 0x05, 0x37, 0xFF, 0xFF, 0xFB, 0x92, 0x64, 0xED, 0x04, 0x04, 0x91, 0x2F, 0xC7, - 0x0B, 0x98, 0x5C, 0x40, 0x40, 0x63, 0x09, 0x6D, 0x0C, 0x25, 0x1A, 0x0F, 0x24, 0xBB, 0x27, 0x4D, - 0xBC, 0xB2, 0xC0, 0xDA, 0x87, 0xE6, 0xF4, 0x30, 0x0D, 0x80, 0xEF, 0x23, 0xFE, 0x50, 0x16, 0x82, - 0x7C, 0xAA, 0xD6, 0xD4, 0xF1, 0x53, 0xEF, 0x39, 0x33, 0x91, 0xF1, 0x6A, 0x3E, 0x7B, 0xF3, 0x3F, - 0x6A, 0xBD, 0x77, 0x98, 0x00, 0x0C, 0x8B, 0x0A, 0x8B, 0x6A, 0xE0, 0xBE, 0xC6, 0x2F, 0x55, 0x6F, - 0xED, 0x28, 0x24, 0x58, 0x78, 0x08, 0x78, 0x26, 0xC9, 0x18, 0x68, 0xB9, 0x33, 0x99, 0x2F, 0x0B, - 0x82, 0x20, 0xF0, 0xC1, 0x77, 0x17, 0xFF, 0x40, 0x64, 0xCB, 0xB8, 0x3C, 0xD5, 0x3C, 0x4C, 0x48, - 0x69, 0x84, 0x1D, 0x03, 0x15, 0x19, 0x6A, 0x21, 0xB5, 0x3A, 0x41, 0x99, 0xCB, 0xA1, 0xE1, 0xC0, - 0x40, 0xC4, 0x00, 0xD8, 0xC8, 0x54, 0x34, 0xC4, 0x10, 0xD4, 0xC2, 0x00, 0x44, 0x20, 0xED, 0x32, - 0xF3, 0x7B, 0x33, 0xCC, 0x1B, 0x36, 0x38, 0x71, 0x0A, 0x89, 0x26, 0x6D, 0x08, 0xC6, 0x26, 0x82, - 0xC6, 0x01, 0x82, 0xE6, 0x1D, 0x89, 0x06, 0xCC, 0x29, 0x03, 0x41, 0xA8, 0x61, 0xDE, 0x62, 0x18, - 0x86, 0x10, 0xBF, 0x23, 0x01, 0x87, 0x41, 0x40, 0x00, 0x2B, 0x03, 0x17, 0xC9, 0xF4, 0x8F, 0xC8, - 0x70, 0x05, 0x6C, 0x9C, 0x42, 0xC2, 0x98, 0x89, 0xA9, 0xB8, 0x61, 0x2D, 0x79, 0x30, 0x0B, 0x9C, - 0xD8, 0x02, 0xD9, 0x9A, 0xC9, 0x30, 0x84, 0xF8, 0x4A, 0xA4, 0xFA, 0xB0, 0x5A, 0xB7, 0xDC, 0x02, - 0x12, 0xCB, 0x4F, 0xB2, 0xA3, 0x2A, 0xE8, 0x1C, 0x4C, 0x69, 0x83, 0xA4, 0x30, 0xC2, 0x07, 0x3F, - 0xCF, 0x80, 0x81, 0x52, 0xB4, 0xAD, 0xFB, 0x3E, 0x66, 0x67, 0x7E, 0x75, 0x64, 0x05, 0xB7, 0x36, - 0xDB, 0x7D, 0xB8, 0x96, 0x21, 0x44, 0xD9, 0xC9, 0xD0, 0x48, 0x1D, 0xB4, 0xA7, 0x14, 0x5B, 0x96, - 0x39, 0xA8, 0x26, 0x89, 0xF6, 0x5F, 0xDD, 0xD8, 0x62, 0xE2, 0x01, 0x89, 0xCA, 0x21, 0x38, 0x1B, - 0x0B, 0x85, 0x45, 0x75, 0x40, 0x45, 0x69, 0x59, 0x30, 0x83, 0x0C, 0x8E, 0x5D, 0xD1, 0x55, 0xC8, - 0x4C, 0x15, 0x28, 0x75, 0xF8, 0xC2, 0x03, 0x14, 0xBE, 0x86, 0x1B, 0x50, 0x49, 0xD4, 0xBC, 0x5D, - 0x9A, 0xCB, 0x3E, 0xB9, 0x99, 0x05, 0x31, 0xE5, 0xAD, 0xB0, 0x08, 0xB1, 0x29, 0x77, 0x9E, 0x38, - 0xB5, 0x90, 0x14, 0x81, 0x33, 0xB6, 0x94, 0x6D, 0x68, 0x5A, 0x6A, 0x00, 0x06, 0x89, 0x73, 0x18, - 0x30, 0xF8, 0xE4, 0xC3, 0xA7, 0x12, 0x26, 0x38, 0x90, 0xA0, 0x30, 0x72, 0x60, 0xA8, 0x31, 0xAB, - 0xC0, 0x84, 0x55, 0x23, 0x0F, 0x02, 0x4C, 0xA2, 0x26, 0x30, 0x88, 0x9D, 0x2D, 0x09, 0x9C, 0x26, - 0x19, 0x4A, 0x81, 0x88, 0xAE, 0xA8, 0x04, 0x5E, 0x8E, 0x45, 0xCA, 0x43, 0x90, 0xB0, 0x58, 0x89, - 0x49, 0x09, 0x6E, 0x69, 0xF4, 0x8B, 0x6F, 0x4A, 0x7E, 0x2A, 0x84, 0xD2, 0x97, 0x02, 0x0A, 0xAF, - 0x58, 0x48, 0xA8, 0x49, 0x3A, 0xC9, 0xEC, 0xA5, 0xFF, 0xFB, 0x92, 0x64, 0xEA, 0x84, 0x03, 0x81, - 0x2E, 0xCB, 0x53, 0x6F, 0x14, 0x40, 0x3A, 0x21, 0xD9, 0xE9, 0x00, 0x23, 0x01, 0x93, 0x88, 0xBD, - 0x18, 0x0E, 0xE5, 0x92, 0xC1, 0x03, 0x0C, 0xA5, 0x8C, 0x33, 0x09, 0x58, 0x7E, 0x94, 0x34, 0x20, - 0x9D, 0x82, 0x04, 0x3B, 0x40, 0xA0, 0xBA, 0xB3, 0x59, 0x9A, 0xC1, 0x20, 0xCA, 0x87, 0x01, 0xD8, - 0xCD, 0xAF, 0xFE, 0xB3, 0x16, 0x8A, 0xD1, 0xA1, 0xF0, 0xF3, 0x90, 0xE3, 0x0C, 0x9C, 0xFF, 0xDD, - 0x56, 0xBD, 0x49, 0xFF, 0xFA, 0x66, 0xED, 0x00, 0x00, 0x40, 0x06, 0x1B, 0x83, 0x13, 0x84, 0xA0, - 0x6A, 0x6A, 0xF7, 0x06, 0x42, 0x44, 0x0E, 0x10, 0xCA, 0xDC, 0xEC, 0x1C, 0x34, 0x73, 0x4E, 0xC7, - 0x7F, 0x9E, 0x24, 0xE9, 0xDB, 0x7F, 0xD3, 0x49, 0xB5, 0x3D, 0x26, 0xC6, 0x24, 0xAB, 0xFB, 0x58, - 0x28, 0xD9, 0xE5, 0xB2, 0xD6, 0x59, 0x62, 0x50, 0x25, 0x15, 0x03, 0x0E, 0x95, 0x60, 0x0C, 0x5C, - 0xF5, 0x30, 0xF4, 0xC4, 0xDD, 0x60, 0x83, 0x00, 0x09, 0x8C, 0x3E, 0x75, 0x3C, 0x3C, 0x18, 0xC6, - 0x26, 0x43, 0x36, 0x26, 0xDC, 0xE3, 0x1A, 0x18, 0xCC, 0x34, 0x1B, 0x14, 0x31, 0x9A, 0x6C, 0x48, - 0x6A, 0x88, 0xB1, 0x83, 0xCB, 0x46, 0x3F, 0x14, 0x96, 0x02, 0xE6, 0xB0, 0x0D, 0x01, 0x80, 0xA8, - 0x49, 0x43, 0xA1, 0x95, 0x05, 0xA8, 0xE0, 0xAA, 0x84, 0x2C, 0x80, 0x80, 0x67, 0x2E, 0xF2, 0x61, - 0xA9, 0x8B, 0x27, 0x5A, 0xE2, 0x30, 0x1C, 0xB2, 0xFE, 0x8E, 0x10, 0x50, 0x7A, 0x7C, 0x31, 0x87, - 0x51, 0x95, 0x4F, 0xB8, 0x6A, 0x2C, 0x97, 0x2C, 0x35, 0xA9, 0x0C, 0x94, 0x03, 0x96, 0x04, 0xE4, - 0x33, 0x12, 0xB5, 0x2E, 0x7B, 0x3F, 0x55, 0xE3, 0xED, 0x0A, 0x41, 0x25, 0x87, 0xF8, 0xB4, 0xFE, - 0x88, 0xE7, 0x55, 0x97, 0x13, 0x86, 0x05, 0x27, 0x05, 0x8E, 0x00, 0xD1, 0x38, 0x0F, 0x17, 0x3B, - 0x55, 0x17, 0xF5, 0x7E, 0x95, 0x8D, 0x7F, 0x7C, 0x92, 0x50, 0xA5, 0xE3, 0xDA, 0xCF, 0xFE, 0x8C, - 0x49, 0x01, 0x08, 0x09, 0xA6, 0xE0, 0x15, 0x80, 0x7B, 0xD6, 0x05, 0x1F, 0x33, 0x9C, 0x3E, 0xE1, - 0x02, 0x21, 0xCC, 0xEC, 0xDB, 0x5A, 0x3C, 0xE1, 0xCD, 0x39, 0x9D, 0xA5, 0x8F, 0x42, 0xEE, 0x79, - 0x51, 0x8D, 0x1C, 0x65, 0x85, 0xDD, 0x5B, 0xDE, 0xDA, 0xC7, 0x8A, 0x8D, 0x00, 0xCB, 0xA1, 0x08, - 0x9A, 0x4D, 0xD8, 0xB8, 0xEA, 0x5A, 0x71, 0xC8, 0x43, 0x13, 0xA1, 0xC3, 0xAB, 0x3E, 0x8A, 0x01, - 0xA7, 0x60, 0xD3, 0x01, 0x85, 0x0D, 0xF9, 0x38, 0x32, 0x58, 0x09, 0x4D, 0x0C, 0x2E, 0x89, 0x31, - 0x9B, 0x6C, 0x00, 0x33, 0x31, 0x39, 0xD8, 0xC0, 0x21, 0xB3, 0x29, 0x12, 0xCC, 0x0A, 0x17, 0x0C, - 0x09, 0x18, 0xAC, 0x42, 0x69, 0x32, 0xD9, 0x80, 0x43, 0x85, 0xC9, 0x3A, 0xA8, 0x3F, 0x0D, 0x6C, - 0xE2, 0x00, 0xD1, 0xA0, 0x21, 0xC6, 0x51, 0x29, 0x2C, 0x12, 0x5D, 0x18, 0x31, 0xEB, 0x56, 0x08, - 0x79, 0x5F, 0x32, 0xC6, 0xBA, 0xAA, 0x8C, 0x29, 0xC0, 0x2B, 0xFF, 0xFB, 0x92, 0x64, 0xE5, 0x8E, - 0x03, 0xBA, 0x2F, 0x48, 0x93, 0x8F, 0x2D, 0x20, 0x34, 0xE1, 0x39, 0xCA, 0x30, 0x03, 0x32, 0x92, - 0x8C, 0xC3, 0x1A, 0x2E, 0x64, 0xF3, 0x00, 0xFC, 0x07, 0xE6, 0xE8, 0x93, 0x08, 0x0A, 0x15, 0xD4, - 0x6E, 0x94, 0x4D, 0x3F, 0x16, 0x0C, 0xC8, 0x1F, 0xB8, 0x3A, 0x20, 0x9D, 0x41, 0xC3, 0xBE, 0x76, - 0x62, 0x36, 0x63, 0xA0, 0xCD, 0x40, 0xC1, 0xA8, 0xE1, 0x51, 0x15, 0x71, 0xF7, 0xFF, 0x4F, 0xEA, - 0x68, 0xE4, 0x7C, 0xC7, 0x1A, 0x08, 0xC3, 0x5F, 0xFD, 0x2A, 0xD6, 0x37, 0xF4, 0x7E, 0xBC, 0x40, - 0x02, 0x00, 0x02, 0x06, 0xE0, 0x11, 0xC2, 0x75, 0xE6, 0xBE, 0xC7, 0x4D, 0x69, 0x09, 0xCE, 0x4C, - 0x63, 0xB9, 0x11, 0x69, 0xE9, 0x4E, 0x9D, 0xB5, 0xE6, 0x87, 0x76, 0x23, 0x09, 0xFF, 0xA8, 0x0C, - 0xDD, 0x05, 0x3B, 0xD7, 0xC5, 0xD2, 0xB6, 0x2E, 0x8A, 0xD6, 0x2A, 0x38, 0x06, 0xAE, 0x91, 0xD2, - 0x85, 0x40, 0xA6, 0x1E, 0x17, 0x1B, 0xAC, 0x80, 0x18, 0x0E, 0x30, 0x50, 0x40, 0xC1, 0x44, 0xF3, - 0x5F, 0x44, 0x4E, 0x6A, 0x54, 0x36, 0x01, 0x44, 0xC3, 0x42, 0x73, 0x24, 0xBE, 0x81, 0x86, 0x20, - 0x30, 0xDC, 0xDD, 0x22, 0x72, 0xD2, 0x19, 0x54, 0x8C, 0x60, 0x56, 0x09, 0xA1, 0xCE, 0x06, 0x7B, - 0x09, 0xA2, 0xF8, 0x00, 0x96, 0xA0, 0x86, 0x2D, 0xF2, 0xF0, 0x30, 0x4C, 0x2C, 0x9A, 0xE1, 0xD1, - 0x1F, 0x51, 0x59, 0xDB, 0x84, 0x45, 0xC8, 0x11, 0x12, 0xBD, 0x19, 0xFA, 0x51, 0x06, 0x16, 0x91, - 0x2C, 0xB5, 0x5D, 0xAA, 0xCB, 0x69, 0x36, 0xB2, 0x44, 0x40, 0x3A, 0x2F, 0xCA, 0x02, 0x0C, 0x73, - 0x92, 0xF2, 0x19, 0x51, 0x16, 0xD3, 0x5B, 0x6A, 0x3F, 0xFB, 0x7E, 0xDA, 0x7B, 0x83, 0x8B, 0x93, - 0x16, 0x9C, 0x0B, 0x09, 0x21, 0xE9, 0x46, 0x5D, 0x3D, 0xAC, 0xC3, 0x27, 0x22, 0x30, 0xF3, 0x14, - 0x0A, 0x3C, 0x10, 0x2D, 0x22, 0xF2, 0x4D, 0xAC, 0x6F, 0x44, 0x72, 0x3B, 0x57, 0x62, 0xC5, 0x1C, - 0xC4, 0x11, 0xA8, 0x0A, 0x04, 0xFF, 0xF6, 0xFA, 0x39, 0x0C, 0x06, 0x00, 0xE5, 0x82, 0x85, 0x35, - 0x5F, 0xB1, 0x88, 0x92, 0xDD, 0x4C, 0xD6, 0x29, 0x35, 0x1D, 0x0E, 0x46, 0x5D, 0xF7, 0xFC, 0x28, - 0x27, 0x09, 0x92, 0x39, 0x10, 0x2A, 0x68, 0x09, 0x6A, 0x5E, 0x35, 0xE3, 0xDA, 0x10, 0x9F, 0x2A, - 0x18, 0x25, 0x3C, 0x0A, 0x4D, 0xA6, 0xA3, 0x97, 0xBF, 0xAE, 0xB5, 0x93, 0x09, 0xBA, 0xB2, 0xD4, - 0x0A, 0x8A, 0x87, 0xEA, 0x00, 0x4E, 0xCB, 0xB2, 0x92, 0xA8, 0x38, 0xC6, 0x21, 0x91, 0x24, 0xF8, - 0x24, 0x2E, 0x60, 0x32, 0xD9, 0x52, 0x20, 0x60, 0xC0, 0xE1, 0x80, 0x83, 0x86, 0x16, 0x0C, 0x99, - 0xB0, 0x6E, 0x62, 0x89, 0x19, 0x89, 0xA1, 0x2B, 0xCC, 0x2F, 0x81, 0x0B, 0x23, 0x22, 0x08, 0x38, - 0x18, 0x64, 0xA8, 0xE2, 0xF1, 0x31, 0xE3, 0x4D, 0x58, 0x47, 0xF6, 0x71, 0xD3, 0x46, 0x3A, 0xD0, - 0x5A, 0x47, 0xB6, 0x8D, 0xA3, 0x66, 0x61, 0x4F, 0xAE, 0x9E, 0x34, 0x6A, 0xFF, 0xFB, 0x92, 0x64, - 0xE4, 0x8E, 0x03, 0xDC, 0x31, 0x48, 0x0B, 0x99, 0x3B, 0xD0, 0x30, 0x05, 0x09, 0xDA, 0x28, 0x03, - 0xB4, 0x93, 0x38, 0xC3, 0x18, 0x2E, 0x64, 0xF1, 0x40, 0xEC, 0x13, 0xE8, 0x24, 0x20, 0x0F, 0x0E, - 0x6B, 0xCD, 0x89, 0x5C, 0x33, 0xA9, 0x87, 0xCE, 0x21, 0x28, 0x62, 0x32, 0xC7, 0x6C, 0x21, 0x5B, - 0xEF, 0xD8, 0x8C, 0x21, 0x82, 0x60, 0xB8, 0xD0, 0xFA, 0x8A, 0x18, 0x73, 0xD0, 0x59, 0x8E, 0x4E, - 0x20, 0x9F, 0xCE, 0x7C, 0x3A, 0x18, 0x5C, 0x22, 0x15, 0x28, 0x75, 0x2E, 0x63, 0xD2, 0x93, 0xB5, - 0xCA, 0xBB, 0x7F, 0x39, 0xC8, 0xA8, 0xE5, 0x97, 0x50, 0x84, 0x42, 0x00, 0x00, 0x39, 0x56, 0x24, - 0x19, 0x9D, 0x8A, 0x84, 0xC3, 0x31, 0x74, 0xD2, 0xEF, 0x24, 0xC7, 0x21, 0x2F, 0x30, 0x3D, 0xFD, - 0x35, 0xB1, 0xCF, 0x7A, 0x0E, 0xAE, 0x1B, 0x24, 0x8B, 0x19, 0x60, 0x89, 0xE5, 0x1E, 0x74, 0xFD, - 0x5F, 0xD6, 0xCE, 0x98, 0xD8, 0xC3, 0x17, 0x11, 0x4A, 0x55, 0xDD, 0x80, 0x00, 0x02, 0xDF, 0xB7, - 0xD7, 0x86, 0x59, 0xF0, 0x10, 0x01, 0xF0, 0xD1, 0xF8, 0xC2, 0x9C, 0xD1, 0x2C, 0x3E, 0x53, 0x1D, - 0x71, 0x18, 0x80, 0xD4, 0x00, 0xC1, 0x8E, 0x02, 0x18, 0xC9, 0x9B, 0x88, 0x04, 0x20, 0x33, 0x6B, - 0x35, 0x22, 0xA5, 0xEE, 0xB0, 0x8C, 0x36, 0x83, 0x11, 0x8A, 0x07, 0x23, 0x38, 0xCD, 0x07, 0x54, - 0x25, 0x86, 0x6A, 0x87, 0x48, 0x44, 0xD5, 0x44, 0x38, 0xE1, 0x37, 0xAF, 0xD8, 0xB7, 0x59, 0x2E, - 0x85, 0x43, 0xB5, 0x39, 0x79, 0xA9, 0x50, 0xF8, 0x44, 0x26, 0x05, 0xFA, 0x92, 0x19, 0x7C, 0x5F, - 0xFF, 0x2B, 0x23, 0xCA, 0x04, 0x49, 0x08, 0x61, 0x43, 0xDC, 0x78, 0x90, 0x09, 0x47, 0xA3, 0xD4, - 0x69, 0x7E, 0x88, 0xB2, 0x6F, 0x50, 0xD5, 0xA1, 0x74, 0x38, 0x57, 0xA7, 0xF6, 0xAF, 0xD6, 0xBF, - 0x56, 0x08, 0x20, 0x21, 0xBF, 0xAF, 0xDC, 0x5B, 0x8A, 0x35, 0x50, 0x36, 0xB4, 0x3A, 0x49, 0x93, - 0xD7, 0xB7, 0x54, 0x7F, 0xE7, 0x06, 0xF8, 0x81, 0x4C, 0x0C, 0x71, 0x8E, 0xC4, 0x01, 0x64, 0x86, - 0x45, 0x46, 0x8D, 0x73, 0xDD, 0x25, 0xEA, 0x60, 0x69, 0xEF, 0x50, 0x60, 0xEB, 0x65, 0x56, 0x35, - 0x7C, 0xCD, 0x69, 0xB7, 0x59, 0x96, 0xB9, 0x44, 0x48, 0x48, 0x96, 0x4A, 0x13, 0x00, 0x05, 0xAB, - 0x4B, 0x45, 0x17, 0xCC, 0x63, 0xB0, 0xCE, 0xC0, 0x4C, 0x60, 0xD8, 0xD8, 0xA2, 0x4E, 0xB2, 0x84, - 0x2A, 0x10, 0x74, 0xD3, 0x03, 0xCE, 0xE3, 0xCC, 0x26, 0x88, 0x48, 0x66, 0x2A, 0xC6, 0x60, 0x52, - 0x65, 0x79, 0x86, 0x8A, 0x46, 0x69, 0x60, 0x40, 0xD1, 0xE0, 0x87, 0x04, 0x42, 0x48, 0x61, 0x00, - 0x79, 0xB9, 0x1A, 0x2C, 0x44, 0x48, 0x5F, 0x09, 0x0E, 0xB0, 0xCC, 0x18, 0x12, 0xA9, 0x2C, 0x21, - 0x04, 0x24, 0x03, 0x7E, 0x59, 0x53, 0x59, 0x2D, 0xEC, 0x6B, 0x4A, 0xDE, 0xA7, 0x0B, 0xD5, 0xA8, - 0x33, 0xF2, 0x13, 0x43, 0x30, 0xB1, 0x03, 0x80, 0x89, 0x1A, 0x13, 0x66, 0x5C, 0xF0, 0xFF, 0xFB, - 0x92, 0x64, 0xE3, 0x04, 0x04, 0x11, 0x2D, 0x48, 0x93, 0x9A, 0x2A, 0xF0, 0x30, 0xC0, 0xC9, 0xD8, - 0x08, 0x23, 0x21, 0x8E, 0xB8, 0xC5, 0x2D, 0x4C, 0xB0, 0x72, 0xC0, 0xF1, 0x0E, 0x26, 0xE8, 0x30, - 0x88, 0x60, 0x43, 0x73, 0xF6, 0x80, 0x12, 0x1A, 0x09, 0x88, 0x87, 0x1F, 0x9B, 0xE5, 0x53, 0x67, - 0xEF, 0xB6, 0x2B, 0x6D, 0x9F, 0xD4, 0x51, 0x15, 0x32, 0xA6, 0x60, 0xE3, 0x71, 0xAB, 0x71, 0x5B, - 0xE4, 0xD3, 0xDA, 0x9F, 0x2A, 0x96, 0x69, 0xEC, 0x31, 0x49, 0x51, 0x8E, 0x76, 0xE4, 0xFE, 0xEF, - 0xF6, 0x53, 0x74, 0x80, 0x00, 0x1F, 0x12, 0x20, 0x8B, 0xE7, 0x3A, 0x87, 0xEA, 0xC8, 0xDB, 0x29, - 0xFE, 0xCF, 0xE7, 0x28, 0xD2, 0xA2, 0x4F, 0xFB, 0x00, 0xAE, 0x26, 0x2E, 0xF5, 0x13, 0xDF, 0xDB, - 0x3D, 0x96, 0x5C, 0xC5, 0xF6, 0xFA, 0xB5, 0x2E, 0xC6, 0x25, 0x17, 0xFF, 0xD1, 0xDE, 0xA8, 0x8D, - 0xBD, 0x4B, 0xD2, 0x85, 0xBD, 0xCA, 0xE8, 0x55, 0x1E, 0x8F, 0xF2, 0x3F, 0x1E, 0xC0, 0x00, 0x00, - 0x32, 0xE4, 0xB5, 0x9D, 0x95, 0x17, 0x2A, 0xFA, 0x54, 0x05, 0xB5, 0x17, 0x1C, 0x11, 0x60, 0x15, - 0xFC, 0xDA, 0xA5, 0x0A, 0x0F, 0x47, 0xD2, 0x21, 0x20, 0xD1, 0x41, 0x76, 0x67, 0x33, 0x48, 0x54, - 0x01, 0x90, 0x20, 0x4C, 0x1C, 0x98, 0x89, 0x7F, 0x97, 0x82, 0x95, 0x19, 0x02, 0x2C, 0x29, 0x96, - 0xCA, 0x7F, 0x94, 0x07, 0x93, 0x32, 0xA5, 0x81, 0x46, 0xC6, 0xB2, 0xD4, 0x2B, 0x8B, 0xA5, 0x01, - 0x7E, 0x5D, 0x4E, 0x9D, 0x71, 0x8A, 0x81, 0x7A, 0x77, 0x15, 0xE1, 0xBC, 0x5C, 0x9A, 0x4C, 0x49, - 0xBD, 0xC1, 0x05, 0x08, 0x30, 0x00, 0xDB, 0xD2, 0x18, 0xEB, 0x2C, 0xB2, 0xBA, 0xCE, 0xD4, 0x82, - 0x75, 0x01, 0x67, 0xD9, 0xB4, 0x6A, 0x10, 0xAB, 0x96, 0xE7, 0xAD, 0xCD, 0xEB, 0x07, 0x15, 0x6E, - 0x39, 0xA0, 0x64, 0x45, 0x54, 0x9F, 0xFE, 0x9D, 0x7F, 0x56, 0x00, 0x00, 0xE0, 0x05, 0x1C, 0x94, - 0x18, 0x1C, 0x1F, 0x42, 0x41, 0x4B, 0x3B, 0x08, 0xF7, 0xAD, 0xFF, 0xC5, 0x78, 0x67, 0xFF, 0xFF, - 0xFB, 0xFC, 0xBF, 0xD9, 0x00, 0xCC, 0x68, 0xEE, 0xBD, 0x4B, 0xCB, 0xE8, 0xAB, 0x12, 0x0B, 0xB5, - 0x93, 0x5A, 0x9F, 0xB9, 0xC1, 0x37, 0xCF, 0xB8, 0x88, 0xE4, 0x20, 0x5E, 0xC2, 0xE7, 0x7D, 0x11, - 0xF7, 0xFB, 0x00, 0x69, 0x1C, 0xF2, 0xA1, 0xE4, 0xD1, 0x65, 0x03, 0x5F, 0x05, 0x0C, 0xAA, 0x44, - 0x52, 0x82, 0x5E, 0x21, 0xBD, 0x8D, 0xC2, 0xD7, 0x50, 0x28, 0xD0, 0xCA, 0x48, 0xF3, 0x21, 0x1C, - 0x87, 0x03, 0x81, 0xCD, 0x51, 0x52, 0xC1, 0x88, 0x46, 0x06, 0xA3, 0x30, 0x1F, 0xB4, 0x86, 0x3D, - 0xA1, 0x6E, 0x82, 0x81, 0xD7, 0xC0, 0xBD, 0x71, 0xD0, 0x84, 0x40, 0x51, 0x4C, 0x2E, 0x31, 0x91, - 0x3F, 0x23, 0x20, 0x62, 0x8A, 0xCA, 0xE9, 0x34, 0xD6, 0x49, 0x1E, 0x04, 0x82, 0x52, 0x2B, 0xB9, - 0x8F, 0x2F, 0x11, 0x20, 0xC8, 0xAB, 0x02, 0x3B, 0x6C, 0x21, 0xD7, 0x42, 0x91, 0xD2, 0xE5, 0x43, - 0xFF, 0xFB, 0x92, 0x64, 0xEF, 0x84, 0x04, 0x8D, 0x31, 0x47, 0x13, 0x78, 0x4C, 0xB0, 0x3A, 0x89, - 0xD9, 0xC8, 0x14, 0x02, 0xF1, 0xCF, 0x90, 0xBD, 0x27, 0x4D, 0x3C, 0x52, 0xC0, 0xE1, 0xA5, 0xA7, - 0xE8, 0x30, 0x8E, 0xBB, 0x83, 0xC2, 0x13, 0x89, 0xB8, 0x97, 0xE3, 0xF2, 0x81, 0x02, 0x1B, 0x06, - 0x64, 0xF3, 0xC2, 0xB0, 0xD1, 0x14, 0xCE, 0xEF, 0xC4, 0x8F, 0x27, 0x27, 0x27, 0x1C, 0xCE, 0x4B, - 0x16, 0xC0, 0xFA, 0xBB, 0xA1, 0x71, 0x89, 0x45, 0xC4, 0xBA, 0x58, 0xDE, 0x69, 0xAA, 0xA3, 0x4D, - 0xE6, 0xD5, 0xAE, 0x75, 0x96, 0x59, 0xE8, 0xDD, 0xFE, 0xFD, 0x38, 0x00, 0x04, 0x32, 0x1D, 0x97, - 0x70, 0xCE, 0x10, 0x09, 0x18, 0x18, 0x41, 0x0F, 0x4A, 0xD0, 0xC3, 0xC0, 0x21, 0x6B, 0x53, 0x40, - 0x61, 0x03, 0xDA, 0x43, 0xA1, 0x09, 0xED, 0xD6, 0x4C, 0x8A, 0x0A, 0xC3, 0x09, 0x39, 0x62, 0x14, - 0x93, 0x6A, 0x43, 0xD8, 0xE7, 0x0C, 0x00, 0xCF, 0xB2, 0x0C, 0x8A, 0x8B, 0xB8, 0x34, 0x71, 0xC8, - 0xE4, 0x09, 0x24, 0x4E, 0x35, 0x48, 0x03, 0xC2, 0xC8, 0x6A, 0xC6, 0x34, 0xE8, 0xB3, 0x34, 0x34, - 0x10, 0x63, 0x4D, 0x62, 0x5F, 0x24, 0xC1, 0x26, 0x26, 0xDE, 0x75, 0xBE, 0x25, 0x6A, 0xC6, 0x2C, - 0x68, 0x3C, 0x44, 0x60, 0x4C, 0x01, 0x43, 0xF3, 0x12, 0x2D, 0x39, 0x02, 0x23, 0x7A, 0x17, 0x80, - 0xC0, 0x84, 0x21, 0x70, 0x10, 0x73, 0x1B, 0x6E, 0x8A, 0x68, 0x07, 0x05, 0x1F, 0xCB, 0x1C, 0xD2, - 0x10, 0x34, 0x4A, 0x79, 0xA1, 0x94, 0x80, 0x80, 0xE0, 0x75, 0xF0, 0xD1, 0x5D, 0xFA, 0x06, 0x7E, - 0xA6, 0x6B, 0x1D, 0x9C, 0x32, 0x75, 0x35, 0x87, 0xE7, 0xAE, 0xDE, 0x77, 0xDD, 0xB6, 0xA0, 0x01, - 0x03, 0x52, 0x12, 0x18, 0x54, 0x38, 0x66, 0x50, 0x11, 0x51, 0xC2, 0x87, 0xAA, 0x25, 0x7B, 0xFF, - 0xA7, 0x66, 0xDC, 0x62, 0x94, 0x83, 0x0A, 0xE2, 0xAD, 0x1C, 0x66, 0xE1, 0x45, 0x2C, 0x95, 0x1B, - 0x04, 0xEE, 0x59, 0xED, 0xCA, 0xFA, 0x6E, 0x45, 0x24, 0x30, 0x02, 0x0C, 0x23, 0xFF, 0x18, 0x27, - 0x46, 0xDC, 0x3A, 0x04, 0xF4, 0xE5, 0x57, 0xFD, 0xCB, 0xFB, 0xAE, 0xBF, 0xFF, 0x4B, 0xA7, 0xA7, - 0xF4, 0xDD, 0x25, 0xB7, 0x6D, 0x48, 0xCE, 0x9F, 0x2B, 0x16, 0x88, 0xC3, 0x3C, 0xC1, 0xE2, 0xC5, - 0x61, 0xE2, 0xEB, 0x7D, 0xF4, 0xE9, 0x48, 0x0A, 0x46, 0xC5, 0x39, 0x0A, 0x00, 0x00, 0x09, 0x52, - 0x95, 0x8C, 0x18, 0x09, 0xD9, 0xCC, 0x9A, 0x99, 0x81, 0x18, 0xB0, 0x88, 0xCC, 0xD9, 0x86, 0xF8, - 0x9C, 0x39, 0xB9, 0x84, 0x9B, 0xA0, 0x90, 0xC5, 0x48, 0xCC, 0x34, 0x74, 0x44, 0x30, 0x10, 0x70, - 0x77, 0x61, 0xC6, 0x46, 0x1E, 0x66, 0x63, 0xE0, 0x42, 0x02, 0x21, 0x86, 0x3C, 0x8D, 0x45, 0xCB, - 0x68, 0x2E, 0xCC, 0x3A, 0x30, 0x1A, 0x56, 0x02, 0xA0, 0xED, 0xFA, 0x81, 0x30, 0x19, 0x7C, 0x34, - 0x1C, 0x07, 0x23, 0x82, 0x18, 0x12, 0x11, 0x47, 0x1C, 0x49, 0x32, 0xFE, 0x8E, 0x38, 0xB9, 0x61, - 0x19, 0x74, 0xFF, 0xFB, 0x92, 0x64, 0xEE, 0x0E, 0x04, 0xA3, 0x2F, 0xC6, 0x0B, 0x9A, 0x63, 0xD0, - 0x41, 0x61, 0x09, 0xAA, 0x0C, 0x63, 0x12, 0x0F, 0x7C, 0xC1, 0x20, 0x4D, 0xA0, 0x5A, 0x00, 0xCF, - 0x1E, 0x69, 0xB0, 0x50, 0x0A, 0x8E, 0x59, 0x01, 0x7C, 0xD8, 0x2A, 0xE0, 0x7E, 0x21, 0x90, 0x46, - 0x2B, 0xEA, 0xE8, 0x46, 0xC2, 0x26, 0x36, 0x09, 0xFF, 0xFA, 0x27, 0x86, 0x87, 0x0B, 0x3D, 0x3A, - 0xBF, 0x1C, 0x5A, 0xFF, 0xFD, 0x68, 0xEF, 0xD1, 0xC8, 0x6B, 0x4F, 0x75, 0x0E, 0xF1, 0xAC, 0x80, - 0x00, 0x02, 0x90, 0x02, 0xD7, 0x6E, 0x2D, 0xD0, 0x09, 0x8D, 0x50, 0x8D, 0x0A, 0x7B, 0x92, 0x2E, - 0x70, 0xB6, 0xD2, 0x59, 0xBD, 0x18, 0xE3, 0x42, 0xAC, 0x7B, 0x7F, 0xEC, 0x56, 0x9E, 0xD0, 0xA9, - 0xCE, 0x89, 0x75, 0x5C, 0x23, 0x0D, 0xAD, 0x67, 0x27, 0x77, 0x25, 0x81, 0xF7, 0x11, 0x55, 0xEA, - 0x5A, 0x1D, 0x3D, 0x8B, 0xBD, 0x08, 0x71, 0x95, 0x92, 0x2D, 0x68, 0xC2, 0x80, 0x18, 0x95, 0x19, - 0x61, 0xC0, 0x00, 0xB1, 0xAF, 0x87, 0x26, 0x05, 0x08, 0x98, 0x1C, 0x8C, 0x60, 0xE1, 0x09, 0x87, - 0xA8, 0x46, 0x06, 0x1A, 0x1B, 0xAC, 0x7E, 0x0D, 0x2A, 0x99, 0x10, 0x40, 0x5A, 0x83, 0x4A, 0xB4, - 0xD4, 0x77, 0x3F, 0xD9, 0x8C, 0x59, 0xD0, 0x87, 0xA1, 0x04, 0xC0, 0x87, 0x14, 0xA1, 0x5D, 0x28, - 0xE0, 0x8C, 0x1B, 0x01, 0x73, 0x2C, 0xA2, 0x63, 0x68, 0xA6, 0x2B, 0xB1, 0x01, 0x90, 0xDA, 0xD1, - 0x41, 0xDA, 0x66, 0x14, 0x0D, 0x02, 0x2C, 0x50, 0x44, 0x05, 0x90, 0x2D, 0x76, 0x29, 0x00, 0x3E, - 0x58, 0x5B, 0x67, 0x56, 0x53, 0xBD, 0x13, 0xD3, 0x55, 0xE4, 0x6E, 0x6E, 0xA0, 0x4C, 0x3A, 0x2E, - 0x71, 0x2B, 0x98, 0x14, 0x81, 0x0C, 0xCB, 0x42, 0x98, 0x82, 0xF9, 0xB7, 0xF5, 0xFC, 0x5D, 0x7D, - 0xA4, 0x50, 0xCA, 0x66, 0xDD, 0x99, 0xBB, 0xD7, 0xA7, 0xD5, 0xF4, 0x0B, 0x1A, 0xB0, 0x70, 0x69, - 0x68, 0x98, 0x14, 0x27, 0x8A, 0xFD, 0x70, 0x00, 0x00, 0x00, 0x00, 0x10, 0xDB, 0x6E, 0x11, 0x8C, - 0x19, 0x33, 0x74, 0xC2, 0x05, 0x03, 0xAA, 0x06, 0x48, 0xAF, 0x3E, 0x4E, 0x77, 0xBA, 0xE7, 0x8A, - 0x5E, 0xE4, 0xB1, 0x1F, 0xFF, 0x80, 0x24, 0x43, 0x3E, 0x91, 0x49, 0xDF, 0x7C, 0xED, 0x77, 0x19, - 0x2D, 0x1F, 0x3C, 0x34, 0xF6, 0xC0, 0x51, 0x75, 0x38, 0xAB, 0x91, 0x6A, 0x83, 0xBA, 0x88, 0x44, - 0x6A, 0x73, 0x3D, 0x85, 0x95, 0x80, 0x00, 0x00, 0x02, 0x9A, 0x92, 0x5C, 0x66, 0xDA, 0x34, 0x08, - 0xD3, 0x1A, 0x82, 0xE7, 0x30, 0xB0, 0x33, 0x01, 0x60, 0x21, 0xE3, 0x22, 0x59, 0x0C, 0x6D, 0x03, - 0x09, 0x02, 0xCE, 0xDC, 0x66, 0x4C, 0xA1, 0x17, 0xA6, 0xC5, 0x40, 0x8A, 0x06, 0x57, 0x3D, 0x4D, - 0x7A, 0xD8, 0x1A, 0x55, 0x0A, 0xA6, 0x6D, 0x47, 0x3A, 0x1E, 0x95, 0x23, 0xA0, 0x30, 0x4F, 0xAB, - 0x62, 0xF8, 0xD3, 0xA5, 0xC2, 0x78, 0xDC, 0x16, 0x09, 0x0C, 0x51, 0xE2, 0x47, 0xA0, 0x50, 0xB1, - 0xE0, 0xA1, 0xDA, 0x2C, 0xFF, 0xFB, 0x92, 0x64, 0xEA, 0x0C, 0x03, 0xF3, 0x2E, 0x48, 0x1B, 0x66, - 0x16, 0x80, 0x3E, 0x01, 0x99, 0xCD, 0x20, 0x49, 0x10, 0x11, 0x40, 0xBB, 0x1E, 0x4E, 0x69, 0x0B, - 0xC0, 0xFA, 0x17, 0xE6, 0xF4, 0x30, 0x8A, 0xA0, 0xC9, 0xBE, 0x1E, 0xE9, 0x33, 0x72, 0x9B, 0x10, - 0x6B, 0x5B, 0x78, 0xB8, 0xDC, 0x72, 0x37, 0x36, 0x69, 0xCE, 0xFB, 0xBF, 0x1D, 0x20, 0x00, 0x08, - 0x0C, 0x34, 0x56, 0xB6, 0xA9, 0x85, 0x1E, 0xB7, 0x22, 0xAB, 0x3E, 0xBD, 0x13, 0x5C, 0xE4, 0x6D, - 0x7D, 0xEA, 0xDE, 0xDF, 0x8C, 0x4C, 0x4A, 0x26, 0xB5, 0x3F, 0xFB, 0x8E, 0xB0, 0x6C, 0xD1, 0xEB, - 0x9C, 0x19, 0x05, 0x05, 0x06, 0x01, 0x4D, 0x30, 0x32, 0x3C, 0x91, 0x6A, 0x48, 0x05, 0xC3, 0x0D, - 0x2F, 0x08, 0x9D, 0x1E, 0x06, 0x04, 0x89, 0x80, 0x32, 0xE5, 0xEA, 0x28, 0xDC, 0x6F, 0x89, 0x60, - 0xA5, 0x53, 0x52, 0x15, 0x32, 0x11, 0xF3, 0x6E, 0xC9, 0x38, 0x2D, 0xB3, 0x78, 0x27, 0x0B, 0x95, - 0x9B, 0x4B, 0x09, 0xB3, 0xD5, 0x19, 0xA3, 0xE9, 0xE4, 0xB8, 0x1B, 0x31, 0x21, 0x9E, 0xA4, 0x99, - 0x81, 0x40, 0x80, 0x48, 0xCB, 0x09, 0x44, 0x82, 0x93, 0xDC, 0xC7, 0x14, 0x16, 0x4A, 0xBA, 0x6A, - 0xE5, 0xC1, 0x2A, 0x21, 0x14, 0x97, 0x19, 0xA1, 0x84, 0x54, 0x11, 0x30, 0x20, 0x42, 0x27, 0xC2, - 0x20, 0x2F, 0xE0, 0xCA, 0xA0, 0x20, 0x19, 0x8B, 0x40, 0x1D, 0x29, 0x5B, 0xD6, 0x7B, 0x1F, 0x64, - 0x4E, 0xDA, 0x95, 0x50, 0x02, 0x78, 0x0A, 0x10, 0xCE, 0x53, 0x49, 0x6D, 0x34, 0xF2, 0x52, 0x5C, - 0xE5, 0xCC, 0x94, 0x06, 0x50, 0x8A, 0xC6, 0x00, 0xBA, 0x88, 0x14, 0x23, 0x8A, 0x43, 0xF2, 0xE8, - 0x0C, 0x66, 0x28, 0x83, 0x7B, 0x6E, 0x0F, 0x03, 0x1C, 0xC1, 0x70, 0xF0, 0x60, 0xA3, 0x62, 0x03, - 0x0B, 0x28, 0x36, 0x04, 0x79, 0xF5, 0x92, 0xC2, 0x65, 0x5D, 0x8C, 0x54, 0xB1, 0x04, 0x31, 0x0E, - 0xF6, 0x39, 0x0F, 0x48, 0x6C, 0x89, 0xD2, 0xC7, 0x5E, 0x9C, 0x00, 0x08, 0x41, 0x71, 0xC9, 0x70, - 0xE5, 0x91, 0x9C, 0x10, 0xC3, 0xC3, 0x13, 0x40, 0xF6, 0x34, 0xEA, 0x2D, 0x26, 0x48, 0x84, 0xB4, - 0x8D, 0x6F, 0xD8, 0x5A, 0x8A, 0x3C, 0x18, 0xD4, 0x1C, 0x6F, 0x69, 0x4F, 0xA3, 0x6A, 0x6E, 0xD9, - 0x15, 0xAF, 0x97, 0x4A, 0x05, 0x0C, 0x25, 0xEA, 0xD0, 0x68, 0x3F, 0x50, 0x16, 0xC4, 0x4A, 0x14, - 0x1A, 0x06, 0x7A, 0x5D, 0x53, 0x50, 0x46, 0x15, 0x78, 0x3F, 0x63, 0xA8, 0x6A, 0x03, 0x49, 0x59, - 0xD9, 0x66, 0xD0, 0x86, 0x08, 0xC2, 0x0A, 0x80, 0x00, 0x00, 0x00, 0x93, 0x73, 0x69, 0x53, 0xEE, - 0xBB, 0x8A, 0x82, 0x0B, 0x08, 0x8A, 0xE8, 0x6E, 0x36, 0x61, 0x29, 0x20, 0x69, 0xDC, 0x14, 0x29, - 0x1C, 0x84, 0x00, 0x58, 0x3A, 0x53, 0xF5, 0xE4, 0x26, 0xAA, 0xA9, 0x17, 0xE5, 0x05, 0x2D, 0x1A, - 0x30, 0x59, 0x24, 0x59, 0xBB, 0x32, 0x57, 0x54, 0x58, 0x56, 0x43, 0x45, 0x13, 0x58, 0x2A, 0xD4, - 0x8C, 0x58, 0xBE, 0x03, 0x03, 0xBF, 0xFF, 0xFB, 0x92, 0x64, 0xE6, 0x84, 0x03, 0x1F, 0x25, 0xCD, - 0xD3, 0x09, 0x1C, 0x44, 0x3A, 0x44, 0x59, 0xF9, 0x08, 0x02, 0xC1, 0x94, 0x4C, 0xBF, 0x14, 0x2D, - 0xE5, 0x32, 0xC1, 0x33, 0x90, 0xA6, 0x28, 0x64, 0x8C, 0xB0, 0x02, 0x77, 0xF0, 0x6C, 0xA2, 0x75, - 0x3C, 0x65, 0x8C, 0xF8, 0x54, 0x3D, 0xEE, 0x25, 0xE9, 0x2A, 0xB1, 0xF9, 0x8D, 0xF3, 0x84, 0x5C, - 0x72, 0x5D, 0x50, 0x2C, 0xC5, 0xB6, 0xB7, 0xFE, 0xFF, 0xF2, 0xFA, 0x2A, 0x48, 0x52, 0x38, 0xFA, - 0xDF, 0x5B, 0x58, 0xAD, 0x3F, 0xFF, 0xD3, 0x73, 0x21, 0x11, 0x03, 0x0C, 0x08, 0xDB, 0x83, 0xE1, - 0x26, 0x10, 0xF6, 0x9F, 0xA6, 0xC1, 0x98, 0x26, 0x81, 0xB1, 0xBF, 0x3C, 0x92, 0x3F, 0xFD, 0x0C, - 0x86, 0x9C, 0x4C, 0x58, 0x97, 0x76, 0x9B, 0x9E, 0xF5, 0xB4, 0x3A, 0x27, 0xA1, 0x14, 0x76, 0x27, - 0x63, 0xEF, 0x32, 0x22, 0x49, 0x85, 0x4E, 0xB5, 0xA6, 0xA0, 0x1B, 0x40, 0x00, 0x82, 0x9C, 0xC1, - 0xF5, 0x03, 0x0D, 0x0D, 0xEC, 0x6F, 0x85, 0x19, 0x71, 0xA6, 0x90, 0x98, 0x0C, 0xD8, 0xDA, 0x93, - 0x66, 0x34, 0x1C, 0x18, 0xFB, 0xBB, 0x35, 0x2B, 0x8C, 0x79, 0x73, 0x52, 0x00, 0xFD, 0x4F, 0x32, - 0x26, 0x47, 0x1C, 0x92, 0x05, 0x1E, 0x9C, 0xD0, 0x97, 0xD1, 0x8C, 0x62, 0xDE, 0x7F, 0xE3, 0x0B, - 0xA1, 0x67, 0xBE, 0xDB, 0x58, 0x36, 0x50, 0xBB, 0xE7, 0x80, 0x42, 0x80, 0x67, 0x6C, 0x91, 0x59, - 0xDC, 0x85, 0xC3, 0x6C, 0x42, 0x2D, 0x5F, 0x16, 0x48, 0xEA, 0xF1, 0xA6, 0x17, 0xF6, 0x99, 0xEE, - 0x67, 0x0E, 0xFF, 0x9C, 0xA7, 0x15, 0x0C, 0x15, 0x72, 0x0F, 0x51, 0x40, 0x18, 0x55, 0x79, 0x5A, - 0xD6, 0xCB, 0x61, 0x01, 0x13, 0x64, 0x57, 0x8C, 0xBA, 0x85, 0x22, 0xCD, 0x9A, 0x2D, 0xF1, 0x63, - 0x78, 0xD7, 0x84, 0x05, 0xD5, 0x2E, 0x45, 0x2C, 0xB6, 0xCF, 0xA9, 0x96, 0x64, 0x62, 0x24, 0x80, - 0x09, 0x4D, 0xFF, 0x59, 0x11, 0xC1, 0x19, 0xA3, 0xAF, 0xF9, 0x1E, 0x0E, 0x5C, 0xF8, 0xF8, 0x8E, - 0xC0, 0xE7, 0x1E, 0xF6, 0xC0, 0x63, 0x02, 0xD7, 0x7F, 0xCB, 0x06, 0x31, 0xB7, 0xA1, 0xE2, 0x01, - 0xCF, 0x51, 0x9B, 0x03, 0xEF, 0x2E, 0x3E, 0x2B, 0x22, 0x20, 0x7A, 0xCB, 0x56, 0xD6, 0x1D, 0xC3, - 0xFD, 0x82, 0xD3, 0x01, 0x47, 0x9A, 0x08, 0x0C, 0x15, 0x69, 0xD5, 0xA2, 0x00, 0x9D, 0x91, 0x40, - 0x00, 0x84, 0x66, 0x60, 0x96, 0x89, 0xA9, 0x82, 0xA9, 0x32, 0x66, 0x25, 0xD1, 0xA9, 0xC8, 0x26, - 0x6E, 0x3F, 0x19, 0x8D, 0xA4, 0x61, 0x81, 0x21, 0xB3, 0x0A, 0x86, 0x90, 0x26, 0x18, 0x90, 0x50, - 0x71, 0x82, 0x48, 0x2B, 0xBA, 0x68, 0x32, 0x00, 0x08, 0x16, 0x66, 0x37, 0x9D, 0x04, 0x0D, 0xC4, - 0x68, 0xF1, 0x82, 0x8E, 0x75, 0x16, 0x16, 0xBD, 0x93, 0x81, 0x44, 0xB1, 0x84, 0xE9, 0x95, 0x88, - 0x94, 0x94, 0x02, 0x04, 0x08, 0x8C, 0x0B, 0x21, 0x0A, 0x82, 0x59, 0xCA, 0x58, 0x5C, 0xF6, 0x65, - 0x0A, 0x44, 0xE4, 0xF2, 0x68, 0x2D, 0x4D, 0xB9, 0xFF, 0xFB, 0x92, 0x64, 0xDE, 0x84, 0x03, 0x5F, - 0x30, 0xCB, 0x53, 0x2F, 0x1C, 0x40, 0x34, 0x61, 0x6A, 0x9D, 0x3C, 0x23, 0x1B, 0x90, 0x40, 0xC5, - 0x20, 0x6D, 0x60, 0xB1, 0x00, 0xFA, 0x11, 0xA9, 0x30, 0x30, 0x89, 0x7E, 0xA2, 0x4A, 0x69, 0x2D, - 0x00, 0x08, 0x14, 0x8C, 0x7E, 0xD5, 0xF2, 0x63, 0xB2, 0x27, 0xF7, 0x0A, 0x8F, 0x80, 0x18, 0x3E, - 0x96, 0x9E, 0x33, 0x3E, 0xBB, 0x4A, 0xD8, 0x61, 0xFF, 0x10, 0xC9, 0xDA, 0xD8, 0xAF, 0x40, 0xC5, - 0x7A, 0xA1, 0xFE, 0x9D, 0x45, 0x48, 0x19, 0xB1, 0x91, 0xF1, 0x7A, 0x37, 0x5B, 0x89, 0xAD, 0x58, - 0xBD, 0x2C, 0x0D, 0x3D, 0x4A, 0x9A, 0x1A, 0x03, 0x40, 0x97, 0x82, 0x00, 0x20, 0x40, 0x8E, 0x4A, - 0x2E, 0x50, 0x74, 0x49, 0x8C, 0xAF, 0x99, 0x89, 0xDF, 0xA6, 0x95, 0x39, 0x69, 0xA5, 0x1F, 0xAE, - 0x59, 0x0B, 0xA1, 0x5C, 0x8A, 0x1A, 0xAE, 0xBD, 0x93, 0xFD, 0xEC, 0xEE, 0xC4, 0xD2, 0x69, 0x95, - 0xAD, 0x9B, 0x6B, 0x53, 0xFE, 0x8F, 0xF7, 0x9A, 0xE6, 0x66, 0x43, 0xBB, 0x2A, 0x99, 0x82, 0x8D, - 0x82, 0x3F, 0x47, 0x48, 0xB0, 0x08, 0x2B, 0x94, 0xB4, 0xA5, 0xCA, 0x6C, 0xC9, 0x66, 0x34, 0x0E, - 0x22, 0x04, 0x32, 0xA2, 0x03, 0x1B, 0x43, 0x34, 0xB4, 0x13, 0x2C, 0x8B, 0x31, 0x43, 0x23, 0x6D, - 0x10, 0x33, 0xA0, 0x4B, 0x15, 0x04, 0x93, 0x1F, 0xF4, 0x96, 0xD1, 0xDD, 0x3D, 0x0D, 0x40, 0x77, - 0xB1, 0xFA, 0x45, 0x53, 0x04, 0x4D, 0xE9, 0x77, 0xAC, 0xA5, 0x9C, 0x35, 0x25, 0x4C, 0x36, 0x4B, - 0x00, 0xC6, 0xD8, 0x73, 0x68, 0xEC, 0xA5, 0x5C, 0xE3, 0xE9, 0x04, 0x51, 0xB9, 0x7C, 0x7B, 0xAC, - 0xBB, 0xB9, 0xC8, 0x25, 0xA5, 0xBF, 0x85, 0x53, 0xCA, 0xA7, 0x48, 0xBA, 0xAA, 0x04, 0x11, 0x10, - 0x08, 0x85, 0xC0, 0x4D, 0x4F, 0x2D, 0x84, 0x09, 0x4C, 0xD6, 0xFE, 0x33, 0x9F, 0x1C, 0x42, 0x1C, - 0xEF, 0xFD, 0xAC, 0xFF, 0xD7, 0xBF, 0xC9, 0xD9, 0x67, 0xFF, 0xD0, 0x70, 0x01, 0x1D, 0xE7, 0x56, - 0x6A, 0x1D, 0xBF, 0xAA, 0xF0, 0x23, 0xF8, 0xE8, 0x66, 0xAE, 0xA4, 0xF3, 0xAB, 0x44, 0x8F, 0x5A, - 0x9F, 0xF8, 0xF1, 0x61, 0x41, 0xC5, 0xA2, 0x27, 0x23, 0xF3, 0x55, 0x14, 0x65, 0xCF, 0xB9, 0x24, - 0xC5, 0x19, 0x2E, 0xBE, 0xC6, 0xD4, 0x28, 0x0C, 0x3B, 0x14, 0x2C, 0xC4, 0x56, 0x2B, 0x01, 0xA1, - 0xE9, 0xC2, 0x10, 0x41, 0x88, 0xEB, 0xE6, 0x3B, 0x09, 0x98, 0x28, 0x54, 0x69, 0x12, 0x91, 0x99, - 0xCF, 0x66, 0x8B, 0x0B, 0x9B, 0x75, 0x0C, 0x20, 0x20, 0x99, 0xA1, 0x1A, 0x28, 0x26, 0x31, 0x30, - 0x78, 0xCF, 0xA6, 0xE3, 0x6D, 0x38, 0xC5, 0x8B, 0x41, 0x81, 0xF0, 0x4E, 0xC1, 0x9F, 0x83, 0x8B, - 0x32, 0x46, 0x49, 0x03, 0xB8, 0xC5, 0xA2, 0x85, 0x0B, 0x30, 0x69, 0x64, 0x89, 0x51, 0xD1, 0x11, - 0x65, 0xBD, 0x63, 0xA8, 0xCC, 0x8A, 0x6A, 0x0C, 0x9E, 0x8B, 0x0A, 0xF3, 0x28, 0x42, 0xF2, 0x66, - 0xEC, 0x01, 0xFE, 0x9E, 0xA0, 0x5C, 0x52, 0xAD, 0xB3, 0x94, 0xFF, 0xFB, 0x92, 0x64, 0xED, 0x0C, - 0x04, 0xCE, 0x31, 0x46, 0x0B, 0x9A, 0x5B, 0xD0, 0x3A, 0xC9, 0xE9, 0xFA, 0x14, 0x02, 0xC2, 0xCE, - 0xCC, 0xBD, 0x22, 0x4D, 0xE8, 0x6B, 0xC0, 0xCC, 0x0B, 0xE9, 0x24, 0x20, 0x8C, 0xFE, 0x66, 0x50, - 0x0B, 0x19, 0xB8, 0x8A, 0xFF, 0xE0, 0x48, 0x08, 0x39, 0x00, 0xE9, 0x82, 0x3E, 0x17, 0xEC, 0xCE, - 0xFE, 0x15, 0xB5, 0xE2, 0x73, 0xF6, 0x1E, 0xBD, 0xA7, 0x2B, 0x67, 0x0F, 0x47, 0x43, 0xC9, 0xF5, - 0x72, 0xBA, 0x16, 0xE2, 0x5C, 0xCA, 0xED, 0x90, 0x8E, 0x0E, 0x45, 0xAD, 0xF4, 0x6E, 0xB8, 0x4B, - 0xB7, 0xE3, 0x8F, 0x18, 0xB6, 0x70, 0x80, 0x08, 0x06, 0x38, 0x1B, 0x01, 0x19, 0x32, 0x93, 0x73, - 0x0E, 0x62, 0xA2, 0x5E, 0x0D, 0x5B, 0x84, 0x46, 0xEA, 0xEA, 0x72, 0xAB, 0x13, 0xE0, 0xC9, 0x81, - 0xED, 0x1B, 0x88, 0x16, 0x09, 0x34, 0xB4, 0x98, 0xBA, 0x0C, 0xBA, 0x79, 0x0D, 0x20, 0x25, 0x3C, - 0x95, 0xDD, 0xC3, 0x83, 0xDE, 0x49, 0xA6, 0xD6, 0xB4, 0x6B, 0x6D, 0x03, 0x40, 0x13, 0x6A, 0x1A, - 0xE3, 0x33, 0x32, 0xC7, 0x21, 0x69, 0x30, 0xE1, 0x80, 0x2A, 0x49, 0x8D, 0x6F, 0x1B, 0x5A, 0x11, - 0x9F, 0x32, 0x98, 0x08, 0x41, 0x90, 0x9F, 0x15, 0x00, 0x4C, 0x38, 0xA0, 0xCD, 0x5D, 0x4E, 0xEF, - 0xE9, 0x0B, 0x0C, 0x24, 0xCC, 0xE1, 0x20, 0x1F, 0xBA, 0xE2, 0x60, 0x0F, 0x38, 0x80, 0xBA, 0xEF, - 0x89, 0x2A, 0x0B, 0xEE, 0xF5, 0x57, 0xF4, 0xAC, 0x07, 0x1E, 0x05, 0x4C, 0xD8, 0x2A, 0xEB, 0xFE, - 0xCA, 0x64, 0x52, 0x4A, 0xCA, 0x5F, 0x9F, 0xEA, 0x11, 0x95, 0x02, 0x8D, 0x22, 0x9A, 0x06, 0x47, - 0xDC, 0x99, 0x0E, 0x6D, 0x21, 0x89, 0x04, 0x74, 0x16, 0x40, 0xEF, 0xA5, 0xA4, 0xCB, 0xF9, 0x88, - 0x35, 0x7F, 0x7D, 0xBF, 0xFC, 0x8A, 0x69, 0x15, 0x40, 0x90, 0x34, 0x92, 0x27, 0xED, 0x2C, 0x1E, - 0x0B, 0xB1, 0x1A, 0x6E, 0x28, 0x61, 0x56, 0xEC, 0x14, 0x52, 0x48, 0x0A, 0xAE, 0x87, 0xE9, 0x4B, - 0xC0, 0xDF, 0x55, 0x74, 0x12, 0x41, 0x02, 0x83, 0xFF, 0x10, 0xC4, 0x17, 0x01, 0x70, 0x59, 0xAD, - 0x55, 0xEE, 0xD4, 0xB5, 0xBF, 0xF6, 0x7B, 0xB5, 0xAD, 0xDA, 0xCC, 0xC6, 0xDD, 0x65, 0x65, 0x53, - 0xED, 0xF3, 0x59, 0x28, 0xE9, 0xB8, 0x43, 0xAA, 0x04, 0xE5, 0x16, 0x39, 0xAC, 0x5A, 0x92, 0x58, - 0x34, 0xF2, 0xE2, 0xB6, 0x34, 0x08, 0xA5, 0xFB, 0x96, 0xB4, 0xD2, 0x7D, 0x0A, 0x00, 0x04, 0x9A, - 0x47, 0x8C, 0xB0, 0x20, 0x09, 0x1A, 0x06, 0x84, 0x18, 0xE0, 0xF8, 0x02, 0x04, 0xC1, 0xD0, 0x0C, - 0xA1, 0xA0, 0x44, 0xB0, 0x67, 0xE4, 0x86, 0x9A, 0x0A, 0x24, 0xF2, 0x66, 0xC3, 0x46, 0x9F, 0x60, - 0x7B, 0xD4, 0x20, 0xE7, 0x53, 0x97, 0x35, 0x1F, 0x70, 0x92, 0x60, 0x30, 0x69, 0x40, 0x08, 0x44, - 0x0D, 0xD3, 0x2A, 0x6C, 0xC5, 0xD6, 0x2F, 0x72, 0x28, 0xD8, 0x8F, 0x3E, 0xD0, 0x7B, 0x8E, 0x81, - 0xED, 0xA4, 0xBD, 0x96, 0x2E, 0x3B, 0x94, 0xF2, 0xD7, 0xDA, 0x7F, 0x2C, 0xFF, 0xFB, 0x90, 0x64, - 0xED, 0x0C, 0x04, 0x60, 0x30, 0xC6, 0x8B, 0x99, 0x33, 0xD0, 0x3E, 0x42, 0x99, 0xC3, 0x14, 0x26, - 0x4A, 0x10, 0xCC, 0xB7, 0x1E, 0x4D, 0xE4, 0xCF, 0x40, 0xE7, 0x19, 0x69, 0xB0, 0xA0, 0x0B, 0x0E, - 0xE1, 0xF9, 0x0D, 0xA6, 0xCE, 0x10, 0xB4, 0x52, 0x0E, 0x60, 0x74, 0xBB, 0xBF, 0x23, 0x8B, 0xE3, - 0x2C, 0x96, 0xCC, 0x61, 0xDA, 0xDF, 0xA8, 0xC0, 0xC9, 0xBB, 0x1D, 0xB2, 0xBF, 0xA1, 0x5C, 0x58, - 0xED, 0xB0, 0x61, 0xEA, 0x77, 0x63, 0x85, 0x28, 0xE8, 0xFE, 0x8E, 0xD1, 0x51, 0x74, 0x96, 0x3A, - 0xE8, 0xE2, 0x21, 0xBF, 0x4B, 0x8C, 0x00, 0x00, 0x08, 0x1A, 0x96, 0x0A, 0x1D, 0xAE, 0x11, 0x8E, - 0x46, 0xBB, 0x25, 0x76, 0x2E, 0x15, 0x6A, 0x1B, 0xF4, 0x53, 0xB8, 0x88, 0xE4, 0xCD, 0x17, 0x4A, - 0x92, 0x46, 0x85, 0x1A, 0x0C, 0x34, 0xAD, 0x29, 0xA6, 0x9C, 0x85, 0xCA, 0xAA, 0x03, 0x45, 0xEC, - 0x41, 0xF7, 0x65, 0xC7, 0xA8, 0x40, 0x0F, 0x02, 0xBB, 0x0D, 0x0B, 0x30, 0xAC, 0x00, 0x00, 0x93, - 0x72, 0x55, 0xA5, 0x86, 0x0C, 0x8D, 0x41, 0xA6, 0x89, 0x3A, 0x0A, 0x2A, 0x60, 0xB1, 0x98, 0x94, - 0x07, 0xA5, 0x08, 0xA8, 0xE0, 0xE6, 0x83, 0xC2, 0x06, 0x41, 0x1A, 0x7A, 0x27, 0x5C, 0x2B, 0x37, - 0x0E, 0x30, 0xED, 0x97, 0x16, 0x24, 0xD5, 0xC1, 0x04, 0xD7, 0xBC, 0x73, 0x18, 0xEB, 0xA5, 0x0B, - 0xC2, 0x06, 0x2D, 0x69, 0x53, 0xA4, 0xE9, 0x7C, 0xDC, 0x46, 0x0D, 0x66, 0x84, 0xEA, 0xC1, 0x61, - 0x9E, 0x21, 0x6F, 0x31, 0x94, 0xD2, 0x0B, 0x81, 0xC4, 0x6B, 0xB9, 0xD3, 0x31, 0x55, 0x3E, 0x3D, - 0x44, 0xB5, 0xB5, 0xD4, 0x3A, 0xD6, 0x3D, 0xB4, 0xF5, 0x83, 0x32, 0x87, 0x82, 0x45, 0xC9, 0x21, - 0x2E, 0xA9, 0x29, 0x70, 0xD4, 0xB5, 0x2E, 0xCF, 0xB0, 0xE0, 0xF4, 0xFA, 0x47, 0x30, 0xF3, 0x84, - 0xF6, 0xEA, 0x44, 0x51, 0xBA, 0xBD, 0x38, 0x00, 0x00, 0x80, 0x66, 0x96, 0xF1, 0x14, 0x18, 0x0B, - 0x41, 0x34, 0x88, 0xC7, 0x0F, 0x0A, 0x00, 0x83, 0x25, 0x00, 0x3B, 0x3F, 0xA8, 0x37, 0x44, 0xA0, - 0x89, 0xB3, 0xE3, 0x45, 0x14, 0x55, 0x25, 0xC8, 0xC5, 0x62, 0xF7, 0x39, 0x0A, 0x34, 0x48, 0x78, - 0xD8, 0xA9, 0x09, 0x17, 0x31, 0xF6, 0x8D, 0xA8, 0x31, 0x64, 0x6D, 0xE7, 0x45, 0x0B, 0xCA, 0x50, - 0xD5, 0x0C, 0x45, 0x00, 0x09, 0xBF, 0xA8, 0x3A, 0x12, 0x62, 0x96, 0xA3, 0x4B, 0xA9, 0xCE, 0x06, - 0x71, 0x39, 0xEA, 0x30, 0xD0, 0xF0, 0xEE, 0xC3, 0x05, 0x33, 0x35, 0x94, 0x93, 0x10, 0x41, 0x31, - 0xE6, 0xB0, 0x62, 0xD1, 0xAD, 0xA0, 0x18, 0xB3, 0x6C, 0xB2, 0x75, 0xC0, 0xCB, 0x52, 0x25, 0xFA, - 0x4E, 0x8B, 0x01, 0x9E, 0xE9, 0xD1, 0x8A, 0x04, 0x6F, 0x10, 0x9A, 0xBB, 0xA0, 0x66, 0xEA, 0xDD, - 0xDA, 0x54, 0x38, 0x55, 0x10, 0x98, 0x26, 0xE2, 0xA3, 0x92, 0xD7, 0xF2, 0x8E, 0xCA, 0xB0, 0xB0, - 0x26, 0x93, 0x0D, 0xAB, 0x73, 0x04, 0x89, 0xC2, 0x25, 0x34, 0x86, 0x2C, 0x40, 0xFF, 0xFB, 0x92, - 0x64, 0xE6, 0x04, 0x04, 0x1D, 0x31, 0xC7, 0x13, 0x79, 0x13, 0xE0, 0x38, 0x00, 0x6A, 0x0C, 0x05, - 0x89, 0x01, 0x8F, 0x38, 0xB9, 0x24, 0xED, 0x3C, 0xB2, 0xC0, 0xF1, 0x01, 0x66, 0xA8, 0x11, 0x84, - 0x00, 0x8D, 0x73, 0xB9, 0x19, 0xE9, 0x65, 0xA2, 0x37, 0xBC, 0x3B, 0x90, 0x08, 0x10, 0x07, 0x80, - 0x69, 0x16, 0xA8, 0x92, 0xB4, 0x7E, 0xBA, 0xE7, 0x48, 0x6B, 0x7A, 0xD8, 0xEA, 0x12, 0xD6, 0x10, - 0x43, 0x86, 0xFC, 0xA6, 0xBA, 0x79, 0x8D, 0x6E, 0x75, 0x00, 0x08, 0x29, 0x29, 0xF4, 0xC7, 0xDA, - 0x78, 0x19, 0xF1, 0xE1, 0x9B, 0x44, 0x08, 0xCA, 0xEE, 0x1D, 0x3A, 0xF5, 0xF2, 0xFE, 0xDF, 0xFE, - 0x8B, 0x95, 0x1B, 0xB2, 0xEF, 0x63, 0x07, 0x72, 0x89, 0x47, 0x17, 0xDB, 0xD2, 0xFB, 0x78, 0x47, - 0x04, 0xC2, 0x62, 0x60, 0xBA, 0x4C, 0x14, 0x0E, 0xDB, 0xED, 0xFA, 0xE5, 0x37, 0xB8, 0xA0, 0x94, - 0x42, 0xE3, 0x56, 0x26, 0x84, 0x00, 0x00, 0x02, 0x00, 0x56, 0x7F, 0xF6, 0xA6, 0xA0, 0x92, 0xC9, - 0xB7, 0xCC, 0xD8, 0x94, 0xC0, 0x0C, 0x8B, 0x38, 0x30, 0x76, 0x92, 0xBE, 0x1C, 0xF4, 0x6F, 0x87, - 0xD1, 0xFD, 0xB1, 0xD8, 0x00, 0x4C, 0x40, 0x52, 0x5C, 0x09, 0xBC, 0x38, 0x48, 0xB9, 0x94, 0x7B, - 0x34, 0x8A, 0xCF, 0x88, 0xCD, 0x1A, 0xFD, 0xAF, 0xE9, 0x54, 0x34, 0x75, 0x49, 0x43, 0xC9, 0x03, - 0x94, 0x4D, 0x4B, 0x42, 0xB7, 0xC8, 0xBA, 0x36, 0xAF, 0x7F, 0xB1, 0x20, 0x80, 0x80, 0x57, 0x1D, - 0xB5, 0x8B, 0x67, 0xB5, 0xCB, 0x6B, 0x5F, 0x17, 0xAE, 0x9A, 0x38, 0xB2, 0xE8, 0x57, 0xF3, 0x7F, - 0xDF, 0x4A, 0x68, 0x92, 0x93, 0x49, 0x49, 0x1B, 0x62, 0x9F, 0xBE, 0xD1, 0x07, 0x40, 0x13, 0x2E, - 0xEB, 0xA9, 0x09, 0x80, 0x5E, 0xA5, 0x0C, 0xB5, 0xBF, 0x93, 0xF4, 0xB4, 0x59, 0x40, 0xB5, 0xB3, - 0x03, 0xDC, 0x14, 0xDB, 0xBB, 0xB2, 0x25, 0x36, 0xA0, 0x40, 0x73, 0x15, 0x91, 0x54, 0xB5, 0x6E, - 0x32, 0x87, 0x5E, 0x86, 0xA5, 0x26, 0xA3, 0x13, 0x86, 0x1E, 0x79, 0x0A, 0x20, 0xE7, 0xD2, 0x71, - 0x84, 0xE5, 0x43, 0x89, 0x2A, 0x85, 0x00, 0x65, 0x2E, 0x58, 0x04, 0x22, 0x66, 0xE5, 0x29, 0x9A, - 0x42, 0xA6, 0x07, 0x0D, 0x19, 0x38, 0x54, 0x70, 0xB0, 0xE9, 0xB6, 0x00, 0x67, 0x1C, 0x3B, 0x01, - 0x92, 0xE6, 0x75, 0x2B, 0x98, 0xA8, 0x38, 0x00, 0x54, 0x9A, 0x39, 0xEE, 0x61, 0x94, 0x51, 0x08, - 0xFC, 0xC5, 0xA3, 0xB2, 0x23, 0x46, 0xE0, 0x1E, 0x48, 0x42, 0x58, 0xAB, 0x63, 0xF6, 0x32, 0xD2, - 0xCD, 0x03, 0x42, 0x53, 0x35, 0xA2, 0xB4, 0xD0, 0x7D, 0x3E, 0xD0, 0x9C, 0x86, 0x46, 0x39, 0x8A, - 0x58, 0xFF, 0x83, 0x1B, 0x59, 0xA3, 0x81, 0x46, 0x98, 0x9B, 0x73, 0x8B, 0xC9, 0xDF, 0x66, 0x5E, - 0xC5, 0x19, 0xA9, 0x71, 0x52, 0x06, 0x57, 0x2D, 0x9A, 0x7D, 0x58, 0x37, 0x05, 0x48, 0x98, 0x20, - 0x51, 0x0A, 0x10, 0x24, 0xD4, 0xE3, 0xA8, 0x45, 0x05, 0x6D, 0x2B, 0x6D, 0xC9, 0xE4, 0xD0, 0xFF, - 0xFB, 0x92, 0x64, 0xEC, 0x00, 0x04, 0x08, 0x21, 0xC7, 0x93, 0x79, 0x33, 0x60, 0x3B, 0xC6, 0x4A, - 0x2C, 0x3C, 0x22, 0x2D, 0x8B, 0xA4, 0xB9, 0x35, 0xAC, 0xA4, 0x4F, 0x41, 0x12, 0x9A, 0x69, 0xB4, - 0xB0, 0x89, 0xBE, 0xEF, 0xBC, 0xB2, 0x9C, 0xF2, 0x85, 0xD3, 0x59, 0x20, 0x13, 0x25, 0xD6, 0xA0, - 0xC4, 0xD5, 0x75, 0x49, 0x30, 0x78, 0xE4, 0x21, 0xA7, 0x78, 0xA3, 0xCD, 0xAA, 0xC7, 0x08, 0x93, - 0x3A, 0xD4, 0x38, 0xF8, 0x49, 0xFE, 0x8F, 0x5A, 0x37, 0xD6, 0xC8, 0x20, 0x24, 0xC9, 0x52, 0x34, - 0x98, 0x92, 0x41, 0xA0, 0x01, 0x6C, 0x25, 0xDE, 0x7D, 0xAF, 0x9F, 0xA7, 0x3D, 0x3D, 0x58, 0x88, - 0xBD, 0xAB, 0x2C, 0xF9, 0x22, 0xCE, 0xE5, 0xB1, 0x10, 0xFF, 0x6C, 0xF7, 0xFC, 0xF6, 0xD8, 0x62, - 0x85, 0xC9, 0xA3, 0x03, 0x78, 0xD3, 0x0B, 0x51, 0xC4, 0x5F, 0xC6, 0x1D, 0xFF, 0xCA, 0xFB, 0xFD, - 0xF6, 0x35, 0xFF, 0x7B, 0x08, 0xB6, 0xFF, 0xB3, 0xF5, 0x73, 0x75, 0x4F, 0x7E, 0x1A, 0xE2, 0x14, - 0xF0, 0xF1, 0x5F, 0x27, 0x64, 0x1C, 0x10, 0x08, 0xAC, 0x6F, 0x3B, 0x5E, 0x33, 0x6C, 0xCC, 0x82, - 0x10, 0x14, 0xD3, 0xB6, 0x2C, 0x39, 0xC1, 0xA2, 0x46, 0x32, 0x3C, 0x60, 0x4E, 0x46, 0x8B, 0x28, - 0x08, 0x45, 0x00, 0x9B, 0xBF, 0xE0, 0x01, 0x50, 0x52, 0xBA, 0x26, 0x33, 0x85, 0x46, 0x3C, 0x52, - 0xB5, 0x64, 0x28, 0x7E, 0xD4, 0xE7, 0xE7, 0x50, 0x16, 0xD0, 0x56, 0x8A, 0xED, 0x82, 0x7E, 0x04, - 0x71, 0x15, 0xA1, 0x9A, 0x56, 0x93, 0xBA, 0x11, 0xAE, 0x4D, 0xB0, 0x77, 0x4E, 0xB8, 0x8C, 0x01, - 0x2D, 0xA1, 0x1D, 0xDF, 0xB3, 0x5F, 0x01, 0x85, 0xA8, 0x16, 0x1C, 0x45, 0xC9, 0x98, 0xF8, 0xD1, - 0xEB, 0xBE, 0x2E, 0x39, 0xA9, 0x18, 0xAB, 0xCD, 0x1E, 0xDA, 0x1C, 0xBB, 0x55, 0xA2, 0x8B, 0x5F, - 0x42, 0xF3, 0xDB, 0xDF, 0xA3, 0xD6, 0x37, 0xCD, 0x37, 0xBD, 0xBF, 0xF5, 0x48, 0x00, 0x0A, 0x92, - 0xA0, 0x96, 0x03, 0x15, 0x61, 0x2E, 0xD0, 0x03, 0x66, 0xA7, 0xDE, 0x7D, 0x2B, 0x11, 0x76, 0x00, - 0x3B, 0x3C, 0x6B, 0x7F, 0x10, 0x1C, 0xC7, 0x01, 0x39, 0x5E, 0x37, 0x85, 0x82, 0x65, 0x52, 0x38, - 0xBF, 0x23, 0x97, 0x89, 0xDF, 0x34, 0xC5, 0x16, 0x8C, 0x4D, 0xC0, 0x67, 0x86, 0xE8, 0xE7, 0xEA, - 0x8C, 0x20, 0x68, 0xAB, 0x52, 0xA5, 0x51, 0x34, 0xD5, 0x02, 0x2A, 0xBE, 0xA0, 0x21, 0x11, 0x81, - 0x77, 0xC6, 0x71, 0x05, 0x28, 0xB1, 0x87, 0x88, 0x06, 0x2E, 0x4E, 0x15, 0x0B, 0x80, 0x6D, 0x89, - 0x80, 0x49, 0x86, 0x45, 0x40, 0x03, 0x94, 0xC6, 0x2E, 0x29, 0x1A, 0x59, 0x5E, 0x68, 0xD1, 0xF0, - 0x5C, 0x9E, 0x61, 0x41, 0xD0, 0x54, 0xAA, 0x0D, 0x0E, 0x32, 0x80, 0xA8, 0x08, 0x72, 0x73, 0x1C, - 0x56, 0x6B, 0x0D, 0xA4, 0x6A, 0x6A, 0xB7, 0xEB, 0xF2, 0x1D, 0xF7, 0xC5, 0x80, 0x83, 0x01, 0x2B, - 0x05, 0xFF, 0x57, 0x41, 0x98, 0x38, 0x8A, 0x62, 0xC1, 0xDA, 0x9C, 0x00, 0xD7, 0x5B, 0x80, 0xD0, - 0x92, 0xFF, 0xFB, 0x92, 0x64, 0xFB, 0x8E, 0x04, 0xF9, 0x30, 0xC5, 0x8B, 0x99, 0x5B, 0xD0, 0x48, - 0x64, 0xBA, 0x3D, 0x20, 0x26, 0x89, 0xCF, 0x54, 0xBD, 0x1E, 0x4D, 0x6D, 0x0B, 0xC0, 0xF1, 0x8C, - 0xE7, 0x64, 0x21, 0x88, 0xB6, 0x87, 0x6C, 0xB8, 0x00, 0x43, 0x54, 0xF4, 0x11, 0xF8, 0x47, 0xE6, - 0xD8, 0x3E, 0x08, 0xE4, 0xD0, 0x17, 0x7E, 0x53, 0x93, 0x6A, 0x78, 0xBE, 0xDE, 0xE4, 0x87, 0xB2, - 0xE1, 0x77, 0x87, 0x12, 0x15, 0x4E, 0xCC, 0xB5, 0x0B, 0x2E, 0x46, 0x35, 0xA3, 0xD6, 0x11, 0x22, - 0xF7, 0x05, 0x34, 0x2C, 0xEA, 0x55, 0x62, 0xEE, 0xEA, 0x73, 0xA1, 0x7D, 0x50, 0x00, 0xB6, 0xA9, - 0x62, 0x23, 0x76, 0x22, 0x10, 0x75, 0x6C, 0xAD, 0x33, 0x20, 0xC2, 0x03, 0x0A, 0x02, 0x23, 0xF3, - 0xD2, 0xCA, 0x18, 0x36, 0x5D, 0xBF, 0x2B, 0x2A, 0x60, 0x92, 0xCB, 0x3A, 0x17, 0x6B, 0xC3, 0x73, - 0x1D, 0xE2, 0x77, 0x8B, 0xC7, 0xBA, 0x72, 0x07, 0x6B, 0x3B, 0x55, 0x97, 0x49, 0x60, 0x45, 0x6B, - 0x98, 0x16, 0x33, 0x7D, 0x8C, 0x74, 0x24, 0x02, 0x00, 0x04, 0x0E, 0xA6, 0xE1, 0x98, 0x8B, 0xC2, - 0x8F, 0x89, 0x71, 0x46, 0x87, 0xE1, 0xCD, 0x92, 0x2A, 0x26, 0x42, 0xDA, 0x3F, 0xAF, 0x14, 0xB1, - 0x74, 0x42, 0x64, 0x60, 0x90, 0x20, 0x64, 0x03, 0xB0, 0x94, 0x0E, 0x05, 0x2D, 0xDD, 0x6B, 0x21, - 0x99, 0x77, 0x18, 0xD5, 0x15, 0x06, 0x46, 0x53, 0x9E, 0xFE, 0x93, 0xF2, 0x1E, 0xCD, 0x53, 0x13, - 0xD1, 0x95, 0x9A, 0x95, 0x08, 0xF0, 0xE7, 0xF9, 0x98, 0x49, 0x8A, 0x25, 0xF1, 0x8A, 0x46, 0x10, - 0x34, 0x96, 0x45, 0x36, 0x33, 0x47, 0xEC, 0xB3, 0x62, 0x05, 0x36, 0x0D, 0x73, 0x49, 0x9C, 0xB9, - 0x82, 0xCC, 0x9C, 0xBF, 0xAF, 0xA4, 0x53, 0x00, 0xB0, 0x03, 0x6D, 0xB8, 0x16, 0x57, 0x21, 0x4F, - 0x74, 0xDC, 0xC2, 0x5C, 0xA9, 0xE3, 0x0B, 0x82, 0x58, 0xD8, 0x39, 0xE7, 0xD3, 0xBF, 0xE5, 0x73, - 0xE1, 0x95, 0x4B, 0xAD, 0xC1, 0x83, 0xE6, 0x15, 0x3A, 0x28, 0xFF, 0x72, 0x1E, 0x71, 0x48, 0xF8, - 0xC4, 0xB5, 0x77, 0xE4, 0x4F, 0x11, 0x79, 0x93, 0x23, 0x89, 0xA1, 0x44, 0x5A, 0x66, 0x35, 0xEA, - 0x80, 0x00, 0x02, 0x8B, 0x96, 0xEA, 0xA4, 0xC9, 0x85, 0x89, 0x0B, 0x36, 0xB1, 0xC3, 0x03, 0x55, - 0x3B, 0x62, 0x40, 0x81, 0x23, 0x6C, 0x27, 0x32, 0xD0, 0x03, 0x0B, 0x20, 0x02, 0x11, 0xB0, 0xE3, - 0x15, 0x0F, 0x33, 0x9A, 0x12, 0xD9, 0xA0, 0x8C, 0xB4, 0x46, 0x08, 0x13, 0x1A, 0x65, 0xA9, 0x3A, - 0xB0, 0xEE, 0xA5, 0x29, 0x9D, 0x1A, 0x06, 0x82, 0x30, 0x1B, 0x4A, 0x7C, 0x5E, 0x36, 0x43, 0x1C, - 0x87, 0xE0, 0x88, 0xF5, 0xB2, 0xDC, 0x07, 0x50, 0x10, 0xD7, 0xF0, 0x38, 0x5B, 0x2D, 0x3A, 0xF7, - 0x69, 0x8E, 0x09, 0x11, 0x14, 0x04, 0xED, 0x98, 0xA9, 0x46, 0x25, 0x9B, 0xEA, 0x42, 0x10, 0x50, - 0x5C, 0xF1, 0x63, 0xCB, 0xED, 0xA9, 0x70, 0xB3, 0x64, 0x52, 0xF3, 0x82, 0xC2, 0xF3, 0x6A, 0x62, - 0xCD, 0x0B, 0x12, 0xFF, 0xFB, 0x92, 0x64, 0xEB, 0x00, 0x04, 0x74, 0x2F, 0x46, 0x0B, 0x99, 0x4C, - 0x40, 0x3A, 0x23, 0x0A, 0x09, 0x04, 0x02, 0x73, 0x8C, 0x04, 0xC5, 0x3D, 0x8C, 0x20, 0x4F, 0xB0, - 0xE9, 0x07, 0xA7, 0x28, 0x01, 0x8C, 0x12, 0x51, 0x47, 0xC4, 0xE8, 0x38, 0xE5, 0x86, 0x77, 0x33, - 0x4F, 0xD5, 0xD4, 0x08, 0x88, 0xF2, 0x46, 0x34, 0x93, 0x1D, 0x64, 0x3B, 0x50, 0x92, 0x91, 0xDD, - 0xAC, 0xF8, 0xB0, 0x4C, 0x7B, 0xF6, 0xD5, 0x6A, 0xAD, 0x56, 0x7E, 0xFB, 0xFA, 0x3A, 0xB8, 0xB5, - 0x72, 0x1C, 0x86, 0x29, 0x1C, 0xCA, 0x2D, 0xDE, 0x8C, 0x88, 0x7F, 0x37, 0xA1, 0xF9, 0x2A, 0x12, - 0x64, 0x62, 0xD1, 0x4E, 0x64, 0x43, 0x32, 0xDF, 0xB7, 0x17, 0xF7, 0x51, 0x15, 0x41, 0xA2, 0x54, - 0x84, 0x79, 0xD3, 0xDA, 0x07, 0x6D, 0x81, 0x06, 0xF4, 0x48, 0x01, 0x14, 0xE4, 0x9C, 0x7F, 0x94, - 0xA4, 0xD4, 0x29, 0x12, 0xA2, 0x20, 0x12, 0x14, 0x8E, 0x6B, 0xA1, 0x08, 0x9E, 0x1E, 0xB3, 0xC0, - 0x60, 0x82, 0x12, 0x21, 0x72, 0x02, 0x33, 0x00, 0x41, 0x66, 0x7F, 0xC1, 0x85, 0x1A, 0x2D, 0x24, - 0x84, 0x18, 0x62, 0x26, 0x48, 0xD3, 0xD5, 0xAC, 0x39, 0xBA, 0x81, 0x3F, 0x70, 0x1B, 0xA5, 0x61, - 0xFA, 0x55, 0x36, 0x4D, 0x4F, 0x07, 0x13, 0x07, 0x94, 0x5B, 0x6E, 0xAC, 0x1E, 0xCD, 0xE8, 0xC5, - 0x27, 0xCD, 0x34, 0x0F, 0x3A, 0x9C, 0xC8, 0x5A, 0x88, 0xC0, 0xD3, 0xE7, 0xD4, 0x48, 0x5C, 0x4C, - 0xAC, 0x1C, 0x7F, 0xB7, 0x38, 0x8E, 0x8C, 0x8D, 0xCA, 0x71, 0x31, 0x84, 0x10, 0x75, 0x1A, 0x08, - 0xDA, 0xDF, 0xFE, 0x7C, 0xFD, 0x23, 0x5F, 0x7F, 0x78, 0xD8, 0x65, 0xC7, 0x1F, 0x5F, 0xC4, 0x0E, - 0xA0, 0x9B, 0x5F, 0xCF, 0x3E, 0xFA, 0x3F, 0xC3, 0xB0, 0x7F, 0x36, 0xAE, 0x8C, 0xF2, 0x17, 0xEC, - 0xEA, 0x7F, 0x0F, 0x20, 0x58, 0x20, 0x78, 0x75, 0x2C, 0x7C, 0x84, 0x0C, 0x13, 0xF4, 0xB5, 0xAF, - 0x23, 0x6E, 0xEB, 0x4F, 0xD1, 0x6D, 0x0A, 0xC6, 0x14, 0x71, 0x2C, 0x61, 0x23, 0xA9, 0x5D, 0x3E, - 0x8B, 0xD6, 0xE8, 0xE8, 0x5B, 0xD7, 0x72, 0xBA, 0x3D, 0xDD, 0x1D, 0x90, 0x8E, 0xA3, 0x9D, 0x9E, - 0x8E, 0x49, 0x1F, 0x39, 0x13, 0xBB, 0x1E, 0x8B, 0xF4, 0xD9, 0x8D, 0x7C, 0x8B, 0x5F, 0xBD, 0x92, - 0xC3, 0x32, 0xCD, 0x8F, 0x30, 0x55, 0x19, 0x05, 0xAA, 0x09, 0x37, 0x05, 0x12, 0x85, 0x8D, 0x22, - 0x6F, 0x30, 0x30, 0x14, 0xC0, 0xE1, 0x73, 0x09, 0x13, 0x8D, 0x7F, 0x7D, 0x32, 0xC2, 0x60, 0xC8, - 0x61, 0xE3, 0x23, 0x01, 0x8C, 0x38, 0x66, 0x30, 0x41, 0xF0, 0xCC, 0x23, 0xB4, 0xE2, 0x3A, 0x12, - 0x5C, 0xC2, 0x42, 0x03, 0x1E, 0x82, 0x52, 0xD4, 0xF7, 0x48, 0x14, 0x5A, 0x82, 0x8C, 0xCE, 0x03, - 0x59, 0x29, 0x10, 0x0E, 0xA8, 0x4B, 0x2C, 0xBA, 0xED, 0x99, 0x02, 0x90, 0x8C, 0xEC, 0x54, 0x26, - 0x15, 0x58, 0xD1, 0x92, 0x07, 0x42, 0x73, 0x31, 0x96, 0x2E, 0xEA, 0x1A, 0xFE, 0xED, 0x2B, 0xB5, - 0xD8, 0xC2, 0xC8, 0x00, 0x2E, 0xFF, 0xFB, 0x92, 0x64, 0xF8, 0x8C, 0x03, 0xF7, 0x2E, 0xC9, 0x3B, - 0x6C, 0x2C, 0xB0, 0x46, 0xCA, 0x1A, 0x2A, 0x08, 0x23, 0xF5, 0xD1, 0x48, 0xC5, 0x22, 0x6D, 0x30, - 0xB8, 0x09, 0x11, 0x25, 0xA7, 0xE4, 0x80, 0x0A, 0x8E, 0xFB, 0x2B, 0x73, 0x27, 0xE8, 0xE0, 0x30, - 0x04, 0x1E, 0x07, 0x61, 0xC8, 0xBA, 0x89, 0x11, 0x1E, 0x6F, 0xAD, 0xEC, 0xD1, 0x97, 0xFF, 0x1D, - 0x5A, 0x92, 0x23, 0x33, 0x07, 0x44, 0x72, 0x2B, 0x85, 0x8C, 0xB8, 0x71, 0x7A, 0x93, 0xED, 0x01, - 0x0A, 0xB1, 0x84, 0xAC, 0x4A, 0x9B, 0x75, 0x8A, 0x77, 0x16, 0xBB, 0xCC, 0x33, 0xB2, 0xAB, 0xBD, - 0x76, 0xB0, 0x52, 0x90, 0x50, 0x1D, 0xB1, 0xB6, 0x3C, 0x08, 0x85, 0x3C, 0xEE, 0xA1, 0x2C, 0xBD, - 0xAF, 0x80, 0xC9, 0x01, 0xB0, 0xC2, 0x7F, 0x62, 0x43, 0x89, 0xFF, 0xFD, 0x9F, 0x7E, 0xD7, 0x3D, - 0x2C, 0xAC, 0xCA, 0x32, 0x95, 0xD2, 0x73, 0x87, 0x05, 0x05, 0x01, 0x8D, 0xA2, 0x36, 0x99, 0x14, - 0x63, 0xC2, 0xC7, 0x57, 0xBC, 0x48, 0x40, 0x5E, 0x75, 0x16, 0xE5, 0x85, 0x3D, 0xF3, 0x5E, 0xA0, - 0x08, 0x7B, 0xCE, 0xE9, 0x7C, 0xC2, 0x0C, 0x53, 0x25, 0x95, 0x2C, 0x19, 0xB0, 0x4E, 0x9B, 0x58, - 0x99, 0x93, 0x05, 0xAD, 0xE3, 0x15, 0x13, 0x0C, 0x15, 0x32, 0x40, 0x13, 0x79, 0x49, 0x1B, 0xAB, - 0x16, 0x19, 0x64, 0x8B, 0xCC, 0x89, 0x05, 0x30, 0xD5, 0x84, 0x60, 0x55, 0x94, 0xC4, 0x53, 0xAC, - 0xB9, 0x0D, 0xD8, 0xD1, 0xDA, 0x49, 0x4B, 0x20, 0xEE, 0x0A, 0x34, 0x71, 0x94, 0x8F, 0x24, 0xCF, - 0x17, 0x0E, 0x43, 0xED, 0x0F, 0x77, 0x83, 0x46, 0x34, 0xA2, 0x50, 0x08, 0x50, 0xB5, 0x7B, 0xA0, - 0x00, 0x1F, 0x0A, 0x28, 0xF4, 0xC4, 0xD1, 0x05, 0x32, 0xC3, 0xCE, 0xB3, 0x15, 0x35, 0x0D, 0x1C, - 0x92, 0x7D, 0xD4, 0xD7, 0x43, 0xDC, 0xF3, 0x21, 0x92, 0x21, 0x16, 0x4B, 0x35, 0x9D, 0x6D, 0xBD, - 0x70, 0xD3, 0xF4, 0x31, 0x14, 0x68, 0xBB, 0xAA, 0xB6, 0x00, 0x02, 0x00, 0x80, 0xB2, 0x34, 0xC4, - 0x40, 0x4C, 0x92, 0x25, 0x3F, 0xBD, 0xE4, 0xCB, 0xFF, 0xED, 0x9C, 0xB7, 0x89, 0x85, 0x00, 0x26, - 0x0D, 0x91, 0x6B, 0xE9, 0x12, 0x03, 0x06, 0x43, 0x2A, 0xC9, 0x32, 0xB5, 0x8C, 0x2C, 0xD0, 0x99, - 0x42, 0x06, 0xE6, 0xB4, 0xF6, 0xF6, 0x7D, 0x05, 0xE7, 0x2B, 0xA6, 0xBA, 0xA0, 0x00, 0x13, 0x5F, - 0x34, 0xC6, 0x44, 0x02, 0x8D, 0x41, 0xA0, 0x40, 0x54, 0x79, 0x04, 0x23, 0x34, 0xFB, 0x05, 0x43, - 0x18, 0x40, 0x8D, 0x1C, 0x20, 0xE0, 0x96, 0x22, 0xC2, 0x33, 0x0E, 0xBC, 0x7E, 0xA2, 0x6D, 0x19, - 0x32, 0x48, 0x1C, 0xD4, 0x5C, 0x55, 0x90, 0x93, 0xA9, 0xC8, 0xE9, 0x2D, 0xF2, 0x78, 0x4F, 0xDE, - 0xAE, 0x56, 0x1C, 0x72, 0x92, 0x18, 0x08, 0x5C, 0xE7, 0xF8, 0xA0, 0x4F, 0xA3, 0x8E, 0xE5, 0xC2, - 0x7E, 0x23, 0x66, 0x17, 0x6F, 0x0C, 0xB2, 0x9D, 0x19, 0xBD, 0xB6, 0xC5, 0x1B, 0x41, 0x0F, 0x0A, - 0x69, 0xCA, 0xAC, 0xF6, 0x5A, 0x23, 0x77, 0xFF, 0xFB, 0x92, 0x64, 0xED, 0x0C, 0x04, 0x9B, 0x31, - 0x46, 0x0B, 0x99, 0x43, 0xD0, 0x3F, 0x24, 0xAA, 0x8D, 0x3D, 0x22, 0x1B, 0x8F, 0x08, 0x8B, 0x20, - 0x4D, 0xBC, 0x72, 0xC0, 0xCF, 0x0E, 0xE9, 0xF4, 0x70, 0x0A, 0xCE, 0xFA, 0xD6, 0x83, 0x90, 0x72, - 0xEE, 0x39, 0xDA, 0xCA, 0xB7, 0xA6, 0xAF, 0x5B, 0x3D, 0x58, 0xBF, 0xAF, 0x67, 0xEE, 0x5F, 0x4D, - 0x08, 0x70, 0x00, 0x08, 0x81, 0x2D, 0xDF, 0x0A, 0x05, 0xC6, 0x66, 0x37, 0xCD, 0x82, 0x3A, 0x4D, - 0xE0, 0x65, 0xAA, 0x42, 0x34, 0x81, 0x19, 0x2A, 0xAC, 0x1C, 0x64, 0xA9, 0x20, 0x97, 0xEE, 0xC5, - 0xCA, 0xE9, 0x76, 0xF6, 0x93, 0x41, 0x53, 0x25, 0x25, 0xEE, 0x22, 0xF3, 0x6B, 0x4A, 0x45, 0x17, - 0x0A, 0x09, 0x04, 0x05, 0x43, 0xE8, 0x38, 0x12, 0x72, 0x8D, 0x3C, 0xCA, 0x89, 0x2E, 0xA8, 0xBA, - 0x2E, 0x1D, 0x62, 0xE0, 0x00, 0x01, 0x5A, 0xAA, 0x38, 0xB1, 0x13, 0x7F, 0x12, 0x2B, 0x02, 0x03, - 0x2D, 0x84, 0x13, 0x00, 0x67, 0x0E, 0x01, 0x1C, 0x42, 0x12, 0x95, 0x26, 0x06, 0x34, 0x23, 0x0D, - 0x0E, 0x41, 0x31, 0x23, 0x71, 0x2A, 0x30, 0x30, 0x71, 0x60, 0x54, 0x9D, 0x00, 0xF3, 0x97, 0x49, - 0xBA, 0x21, 0xD5, 0x84, 0xBE, 0xEF, 0xA0, 0x80, 0x41, 0xCE, 0xA7, 0x6E, 0x30, 0x33, 0x60, 0x76, - 0x1D, 0x35, 0x22, 0xE8, 0x75, 0x7C, 0x3E, 0x4C, 0xD2, 0x91, 0xDB, 0x4B, 0x8C, 0xF4, 0xE5, 0xDE, - 0xAB, 0x59, 0x78, 0xD3, 0xB7, 0x8F, 0x9D, 0x2D, 0xC3, 0x89, 0x51, 0x50, 0x5D, 0xD1, 0x45, 0x07, - 0xA4, 0xA1, 0x66, 0xAE, 0x82, 0x1C, 0x6B, 0xFB, 0xAA, 0x88, 0x1E, 0xD1, 0xC2, 0x29, 0x94, 0xA2, - 0xC4, 0x29, 0x42, 0xAA, 0x0C, 0xE2, 0xAF, 0xCB, 0x5E, 0xA1, 0x38, 0xD1, 0xAC, 0x4A, 0x49, 0x26, - 0x62, 0xCA, 0x50, 0xD5, 0x92, 0xDE, 0x85, 0xD2, 0xD3, 0x1A, 0x39, 0x43, 0x00, 0x16, 0xAD, 0x0B, - 0x74, 0xBB, 0x40, 0x06, 0x46, 0x56, 0x94, 0x13, 0xED, 0x36, 0xD8, 0xDD, 0xCF, 0x04, 0x20, 0x71, - 0x43, 0xE1, 0x9C, 0x32, 0x71, 0x3F, 0xC5, 0x9D, 0x7A, 0x4C, 0x1D, 0x26, 0xA4, 0x4D, 0x30, 0x0A, - 0xE3, 0xE0, 0x98, 0xAB, 0xCA, 0x96, 0x7E, 0xD0, 0x2D, 0x5B, 0x0B, 0xA8, 0xC8, 0x12, 0x94, 0xCF, - 0x5F, 0x52, 0x52, 0x4A, 0xA6, 0x8F, 0xD6, 0x79, 0xD4, 0xEB, 0x4F, 0x46, 0x8A, 0x00, 0x48, 0x58, - 0x8B, 0xC4, 0x30, 0x13, 0x34, 0x10, 0xB4, 0xC6, 0x81, 0x53, 0x05, 0x81, 0x8C, 0x88, 0x45, 0x31, - 0x2C, 0x4C, 0xC0, 0x25, 0x43, 0x0D, 0x8E, 0x84, 0x00, 0x83, 0x13, 0x13, 0x4C, 0x36, 0x1E, 0x31, - 0x28, 0xB8, 0x08, 0x27, 0x38, 0x91, 0x1A, 0x22, 0x08, 0x0B, 0x98, 0x98, 0x72, 0x1C, 0x86, 0x6A, - 0x63, 0xC0, 0x07, 0x78, 0x0E, 0x45, 0xB6, 0xC4, 0xC4, 0x68, 0xB6, 0xF4, 0xBF, 0xCB, 0x4D, 0xD4, - 0x76, 0x55, 0x44, 0xD6, 0x57, 0xB6, 0x65, 0x7B, 0x2F, 0xC8, 0x06, 0x95, 0x34, 0x64, 0x75, 0x2F, - 0xBB, 0x9D, 0x91, 0x38, 0x08, 0x26, 0x06, 0xB5, 0x83, 0xFF, 0xFB, 0x92, 0x64, 0xEC, 0x84, 0x03, - 0x7D, 0x2F, 0x49, 0x33, 0x4F, 0x14, 0xB0, 0x43, 0xA1, 0x29, 0xBD, 0x0D, 0xE9, 0x14, 0x10, 0xE0, - 0xC3, 0x1F, 0x2D, 0xE0, 0xAF, 0x41, 0x09, 0x06, 0x67, 0xF4, 0x54, 0x8C, 0xC4, 0xBA, 0x50, 0xED, - 0x58, 0x80, 0xE4, 0x40, 0x40, 0x28, 0x8B, 0x31, 0x07, 0xB9, 0x0C, 0xDA, 0x95, 0x54, 0x53, 0x2A, - 0xA7, 0xD6, 0x71, 0xF1, 0x50, 0x70, 0x06, 0x2A, 0xE3, 0x02, 0x89, 0x7B, 0x4D, 0x2C, 0x65, 0xBD, - 0xED, 0xD5, 0x6E, 0x91, 0x5B, 0x58, 0xBA, 0x7A, 0xE4, 0x8C, 0x0F, 0xAD, 0x65, 0x49, 0x74, 0x9E, - 0x9A, 0xC0, 0x80, 0x00, 0x08, 0x00, 0x27, 0xDB, 0xFF, 0x60, 0x35, 0xAE, 0xD6, 0x28, 0xC1, 0xA1, - 0x6C, 0x6F, 0x08, 0x14, 0x7F, 0x8E, 0x29, 0x3C, 0xAB, 0x9A, 0xFF, 0xE6, 0xDB, 0xC7, 0x29, 0x82, - 0xC9, 0x17, 0x58, 0xD3, 0xF4, 0x2C, 0xAA, 0x98, 0x78, 0x9B, 0x9B, 0xAA, 0xC6, 0x25, 0xF9, 0xA7, - 0x80, 0xCA, 0x95, 0xB2, 0x52, 0x7A, 0x61, 0x3A, 0x1D, 0x4A, 0xD5, 0xB5, 0x5E, 0x8B, 0x3A, 0xD3, - 0x4C, 0x00, 0x02, 0xDB, 0x71, 0xEE, 0x9F, 0x43, 0x10, 0x50, 0x92, 0x94, 0x00, 0xE4, 0x47, 0x3A, - 0x32, 0x1B, 0x98, 0x91, 0xE4, 0x26, 0x40, 0xCA, 0x81, 0x42, 0x41, 0xC6, 0x42, 0xE8, 0x8C, 0x2B, - 0x14, 0xA7, 0x30, 0xA6, 0x84, 0x02, 0xC1, 0x44, 0x1F, 0xBC, 0x98, 0x1A, 0x86, 0xEE, 0xA3, 0xC7, - 0xA5, 0xC6, 0x4A, 0xE6, 0x26, 0xE2, 0x78, 0xC4, 0xB2, 0xB9, 0xC4, 0xEC, 0xAE, 0xFA, 0xF4, 0xAF, - 0xBF, 0xC7, 0x70, 0xF9, 0x75, 0xCA, 0xD6, 0x73, 0x0E, 0x9C, 0xAB, 0xDE, 0xF3, 0xA2, 0xBD, 0xAB, - 0xEB, 0xEC, 0x94, 0x01, 0x1F, 0x7F, 0x7F, 0xB9, 0xDD, 0x1F, 0xA3, 0x65, 0x8D, 0x55, 0x6C, 0xD7, - 0x9E, 0xF4, 0x52, 0x00, 0x00, 0x20, 0xE2, 0x52, 0xC8, 0xE0, 0xE9, 0x96, 0xD8, 0x34, 0xB3, 0x36, - 0xE7, 0x49, 0xCD, 0x24, 0xF2, 0xE3, 0x0E, 0x8B, 0x1F, 0xC9, 0xAE, 0x0A, 0x20, 0x23, 0x34, 0x97, - 0x3D, 0x42, 0x6B, 0x45, 0x50, 0x13, 0xDB, 0xA8, 0xE8, 0xE2, 0xBB, 0xF6, 0x6A, 0x55, 0xD4, 0xFC, - 0x74, 0xB2, 0xC0, 0xF4, 0xA7, 0xEE, 0xDB, 0xD5, 0xDA, 0x31, 0x9D, 0x95, 0x97, 0x36, 0x14, 0xCC, - 0x33, 0x53, 0x04, 0x49, 0xDC, 0x20, 0x1B, 0x98, 0xA4, 0xE8, 0x64, 0x99, 0x71, 0xA8, 0x90, 0x06, - 0x9A, 0x46, 0x1A, 0x34, 0x14, 0x64, 0x04, 0xE9, 0x10, 0xFC, 0xCD, 0x29, 0x63, 0x4F, 0x16, 0x4D, - 0x7A, 0x7A, 0x2E, 0xD9, 0x84, 0xC0, 0xC3, 0xD1, 0x1F, 0x82, 0x99, 0x83, 0xB9, 0x61, 0x48, 0xC4, - 0xE6, 0x49, 0xD2, 0x8A, 0x04, 0x66, 0x21, 0x0A, 0xAC, 0x93, 0x02, 0x07, 0x4C, 0xC5, 0xAC, 0xCC, - 0xD1, 0xCE, 0x05, 0x52, 0xC2, 0xAA, 0x04, 0x4B, 0x35, 0xE5, 0xD2, 0xF8, 0xBF, 0x8E, 0xAC, 0x71, - 0x98, 0xC1, 0xFB, 0x7D, 0x44, 0x2A, 0x38, 0xE8, 0xE3, 0x3C, 0xD2, 0x62, 0xC3, 0xC2, 0x81, 0xC4, - 0x11, 0x27, 0xAA, 0xBB, 0x21, 0xAC, 0x74, 0x99, 0xC5, 0x32, 0xE7, 0xFF, 0xFB, 0x92, 0x64, 0xED, - 0x04, 0x04, 0x80, 0x2F, 0x47, 0x13, 0x98, 0x2C, 0x40, 0x3F, 0xA1, 0x89, 0xCD, 0x24, 0x23, 0x30, - 0x0C, 0x30, 0xB9, 0x28, 0xED, 0x30, 0xB2, 0xC0, 0xE5, 0x19, 0xE7, 0xB4, 0x90, 0x8A, 0x3C, 0x9E, - 0xE1, 0x48, 0x98, 0xDD, 0xD7, 0x47, 0xE9, 0xC2, 0x62, 0x3A, 0x92, 0x13, 0x12, 0xA8, 0x4F, 0x07, - 0xD2, 0xF1, 0x05, 0x84, 0xAA, 0x52, 0xC2, 0x22, 0xDA, 0x4D, 0x25, 0x88, 0x28, 0xF7, 0x2E, 0x28, - 0x59, 0xFC, 0xED, 0xAA, 0xEC, 0xD1, 0x6F, 0x44, 0x82, 0x9A, 0x0E, 0x49, 0x1B, 0x63, 0xAE, 0x4D, - 0x05, 0x2B, 0x08, 0xA7, 0x3D, 0xF4, 0xE2, 0x2A, 0x80, 0xD3, 0x0E, 0x14, 0x39, 0xFF, 0xF9, 0x79, - 0x21, 0xE5, 0x21, 0x5A, 0xE6, 0x7E, 0xDA, 0xE5, 0xD2, 0xD7, 0x35, 0x52, 0x85, 0x6B, 0x6B, 0x9F, - 0xC6, 0x92, 0xB9, 0x3A, 0x3A, 0x6C, 0x76, 0xBB, 0x5A, 0x67, 0x0F, 0xE3, 0xCA, 0xF4, 0x86, 0x22, - 0x40, 0x9A, 0x13, 0x62, 0xAC, 0x78, 0x41, 0x49, 0x52, 0x05, 0x31, 0x73, 0x08, 0x21, 0x65, 0x24, - 0x00, 0x01, 0x76, 0xDF, 0xF4, 0x4A, 0x19, 0x6B, 0x45, 0x81, 0x0F, 0x0D, 0xC2, 0x58, 0x51, 0x60, - 0x82, 0x9A, 0x68, 0x5C, 0x58, 0x90, 0x0A, 0xAC, 0xCE, 0xCC, 0x44, 0x69, 0x90, 0xEA, 0x94, 0x84, - 0x85, 0x77, 0xB8, 0x86, 0x32, 0x5F, 0x02, 0x76, 0x56, 0x42, 0xCB, 0xD0, 0xB4, 0xEA, 0xDA, 0x9D, - 0x6E, 0x72, 0xE6, 0xED, 0x8C, 0x45, 0x5D, 0x68, 0x89, 0xD3, 0x96, 0x03, 0x12, 0x02, 0xC8, 0x24, - 0x16, 0xB6, 0x49, 0x2C, 0x8C, 0xBF, 0x8B, 0x24, 0xBC, 0x95, 0xC7, 0xDF, 0xFE, 0xB8, 0x5C, 0xDA, - 0x01, 0x48, 0xB6, 0xF0, 0x48, 0xA8, 0xB5, 0xF3, 0xB7, 0x77, 0x24, 0x96, 0x77, 0x53, 0xD5, 0xA2, - 0x01, 0xA0, 0x2B, 0x0A, 0xC1, 0xA8, 0x1F, 0x38, 0xFA, 0xCE, 0x4D, 0x65, 0x96, 0xFE, 0x66, 0xD4, - 0x0C, 0x7F, 0xF7, 0xB5, 0x0A, 0x7B, 0x3E, 0xA1, 0x76, 0x50, 0xE3, 0xC1, 0x12, 0x05, 0xC3, 0xA4, - 0x0E, 0x25, 0xE2, 0x6A, 0xB5, 0x8D, 0xAD, 0xC8, 0x18, 0x80, 0x4C, 0x1C, 0x51, 0x37, 0x25, 0x17, - 0xCC, 0x43, 0x40, 0xD3, 0x6A, 0xEA, 0xA1, 0xA9, 0x80, 0x00, 0x00, 0x00, 0x52, 0xAE, 0x39, 0x6A, - 0xB6, 0x0C, 0x00, 0x9E, 0x5E, 0x12, 0x5A, 0x18, 0xC0, 0xE1, 0x84, 0x9A, 0x99, 0xF0, 0x88, 0xCA, - 0x29, 0xB4, 0xB5, 0x18, 0xB0, 0x88, 0x73, 0x51, 0xA5, 0x23, 0x18, 0x90, 0x91, 0xDB, 0xA0, 0x19, - 0xA9, 0x0B, 0xE8, 0x66, 0x2E, 0xDD, 0x8C, 0x45, 0x14, 0xE5, 0x7F, 0x8C, 0x2A, 0x4D, 0x3D, 0x33, - 0x5A, 0x1C, 0x05, 0x0D, 0xED, 0xC8, 0xD5, 0xB4, 0x2E, 0x1A, 0xE9, 0x63, 0x48, 0x77, 0xAD, 0x1B, - 0x5F, 0x66, 0x70, 0x36, 0x24, 0x73, 0xEF, 0xE4, 0x07, 0x8B, 0x22, 0x78, 0x55, 0x8A, 0xBA, 0x9F, - 0x64, 0xB1, 0x2B, 0x15, 0x9E, 0x37, 0xA1, 0xFF, 0x87, 0x70, 0xA6, 0xA7, 0xB3, 0x8D, 0x2C, 0xAB, - 0xBA, 0x6D, 0xAC, 0x4D, 0x74, 0xBC, 0x4B, 0x21, 0x25, 0x50, 0xEA, 0xAB, 0xE8, 0xFF, 0xFB, 0x92, - 0x64, 0xF6, 0x84, 0x04, 0xAF, 0x2E, 0x45, 0x83, 0x99, 0x5B, 0xD0, 0x48, 0xC7, 0x7A, 0x6D, 0x3C, - 0x23, 0x4F, 0x8C, 0x08, 0xA5, 0x33, 0xAC, 0x30, 0x4F, 0x40, 0xE4, 0x85, 0x67, 0xA4, 0x21, 0x98, - 0x0E, 0x1B, 0xF4, 0x0A, 0x02, 0xFD, 0x8D, 0x80, 0xFC, 0xB9, 0x17, 0x13, 0x63, 0x94, 0x40, 0x61, - 0x86, 0x1E, 0xD9, 0x50, 0x1C, 0xC0, 0xE3, 0x65, 0x16, 0x85, 0x6C, 0x78, 0xEA, 0x54, 0xB5, 0xAE, - 0xA9, 0x86, 0x45, 0x5D, 0x17, 0x28, 0x35, 0xA9, 0x27, 0x99, 0xCA, 0x34, 0x6F, 0x0A, 0x68, 0xF6, - 0xA7, 0x3A, 0x38, 0x44, 0x99, 0x78, 0x7E, 0xA8, 0x77, 0xCA, 0xAF, 0xE3, 0x2E, 0xF5, 0xF8, 0xF9, - 0xA9, 0x3E, 0x00, 0x02, 0x00, 0x20, 0x01, 0x96, 0x5D, 0x85, 0x0A, 0x22, 0x1A, 0x4B, 0x24, 0x42, - 0xA8, 0xA8, 0x0C, 0x86, 0x51, 0x8D, 0xA1, 0xB9, 0x35, 0x4A, 0x67, 0xD6, 0x6E, 0x1B, 0x15, 0xF5, - 0xFD, 0x4F, 0x00, 0x97, 0x46, 0xE7, 0xEA, 0xE7, 0xCE, 0x9D, 0x75, 0xF1, 0x93, 0x5B, 0x56, 0xAD, - 0x01, 0x4A, 0xC9, 0xAC, 0x6D, 0x07, 0x05, 0xE5, 0x4D, 0x89, 0x12, 0xAB, 0xED, 0x48, 0xC8, 0x78, - 0xD2, 0x19, 0x36, 0x94, 0xD2, 0x3A, 0x00, 0x00, 0x00, 0x04, 0xA4, 0x8E, 0x01, 0x55, 0x68, 0x70, - 0xE8, 0x01, 0x22, 0x01, 0x36, 0x10, 0x34, 0xDD, 0x6A, 0x2F, 0xC8, 0x18, 0x12, 0xA3, 0x31, 0xC2, - 0xD5, 0x44, 0x44, 0xBC, 0x18, 0x20, 0xCD, 0x8F, 0x2F, 0x91, 0x85, 0x0C, 0x77, 0x80, 0xAA, 0xD2, - 0x58, 0x49, 0x68, 0xCE, 0xC4, 0x13, 0xF4, 0x87, 0x3E, 0xAA, 0x8D, 0x9A, 0x3A, 0x9E, 0x33, 0x8C, - 0x47, 0xA9, 0x58, 0x91, 0x3C, 0xD8, 0xEA, 0x75, 0x1C, 0x77, 0x31, 0xF0, 0xA7, 0x8D, 0x35, 0x28, - 0x00, 0xED, 0xF7, 0xF9, 0x4B, 0xFF, 0xFF, 0x76, 0x2C, 0x30, 0xEA, 0xAA, 0x31, 0x0D, 0x77, 0xB9, - 0x77, 0xE3, 0xBA, 0xBD, 0xB9, 0x5A, 0xBA, 0x56, 0xE1, 0x8E, 0xFF, 0x7C, 0x08, 0x00, 0x01, 0x00, - 0x2E, 0x96, 0x30, 0x12, 0x9B, 0x83, 0x0C, 0x8B, 0x04, 0xCA, 0x4A, 0x92, 0x6F, 0xFF, 0x50, 0xC3, - 0xC2, 0x85, 0x4B, 0x91, 0x6D, 0x31, 0x64, 0x09, 0xE9, 0x73, 0x98, 0xFA, 0xD2, 0x39, 0x22, 0x04, - 0x5A, 0x42, 0x67, 0xAE, 0x9F, 0xB5, 0x1C, 0x76, 0x98, 0x84, 0xD8, 0xE6, 0x92, 0x58, 0xF2, 0x55, - 0x2A, 0x80, 0x00, 0x00, 0x00, 0x13, 0x6E, 0x3A, 0xD0, 0x18, 0xE8, 0x83, 0x36, 0x39, 0x26, 0x41, - 0x49, 0x82, 0xA8, 0x42, 0xCA, 0x8E, 0x81, 0xE2, 0xF8, 0x88, 0x03, 0x1B, 0xF5, 0x8F, 0xA1, 0x84, - 0x2C, 0x42, 0x34, 0xE8, 0xA0, 0x30, 0x61, 0xCC, 0xD8, 0x24, 0xC4, 0x44, 0x68, 0x19, 0x73, 0x29, - 0x7A, 0x59, 0x4C, 0xBB, 0x74, 0x27, 0x1B, 0xC2, 0x3C, 0x88, 0xC9, 0x8B, 0x83, 0x13, 0xA3, 0x45, - 0x45, 0xF2, 0x52, 0x96, 0x8C, 0xE5, 0x18, 0xD2, 0x07, 0x17, 0x34, 0x0C, 0x95, 0x96, 0x6A, 0xF4, - 0x24, 0x05, 0x1C, 0xFB, 0x96, 0x27, 0x5C, 0xC6, 0xEC, 0x74, 0xEB, 0x44, 0xB6, 0x82, 0x51, 0xFF, - 0xFB, 0x92, 0x64, 0xF9, 0x84, 0x05, 0xAE, 0x65, 0x46, 0xD3, 0x79, 0x43, 0x70, 0x44, 0x04, 0xF9, - 0x9D, 0x24, 0x23, 0x98, 0x0C, 0xBC, 0xC5, 0x29, 0xAD, 0x3C, 0x4F, 0x40, 0xD2, 0x01, 0xA8, 0x70, - 0x90, 0x8C, 0x06, 0x20, 0x51, 0x01, 0xA2, 0xEA, 0x39, 0x39, 0x23, 0x48, 0x98, 0x63, 0xB4, 0xD6, - 0xC8, 0xCB, 0xED, 0x43, 0x5A, 0x1B, 0x5E, 0xC6, 0x25, 0xE0, 0x07, 0xF9, 0xBA, 0x75, 0xB7, 0x62, - 0x20, 0x00, 0x00, 0x08, 0x06, 0xDA, 0x93, 0x62, 0x2E, 0x0A, 0x2F, 0x0A, 0x1C, 0xA7, 0x29, 0x1B, - 0x13, 0x24, 0xE8, 0xA8, 0xD6, 0x8D, 0xD9, 0x29, 0xF4, 0xC8, 0xA7, 0x55, 0x3D, 0x83, 0x9C, 0xAA, - 0x49, 0xFC, 0x12, 0x26, 0x54, 0x1C, 0x6E, 0x51, 0x20, 0x5C, 0xE5, 0xC3, 0x23, 0x4C, 0x2D, 0x6C, - 0x48, 0x79, 0xAB, 0x7F, 0xD1, 0xED, 0x59, 0xA3, 0xF4, 0xC5, 0x12, 0x77, 0x7D, 0xE8, 0x54, 0x85, - 0x1F, 0xF1, 0x5B, 0xAA, 0x26, 0x42, 0x0D, 0x99, 0x46, 0x20, 0x86, 0x0A, 0xA6, 0x04, 0x04, 0xC6, - 0x0A, 0x0A, 0xE6, 0x52, 0x49, 0xA6, 0x6E, 0x18, 0x26, 0x4A, 0x8D, 0x88, 0x4F, 0x30, 0xF9, 0x11, - 0x05, 0x0D, 0xC6, 0x40, 0x89, 0x26, 0x36, 0x97, 0x66, 0x30, 0x29, 0xC0, 0x22, 0x30, 0x99, 0x3B, - 0x0E, 0xF0, 0xA7, 0xA2, 0xD1, 0xB3, 0x34, 0xD0, 0x16, 0xEA, 0x74, 0x04, 0x24, 0xF2, 0x1A, 0x2B, - 0x36, 0x42, 0xA2, 0xA8, 0xBB, 0x4B, 0xA7, 0x0E, 0x69, 0x03, 0x11, 0x21, 0xA4, 0x2E, 0xD4, 0x26, - 0xB8, 0xF2, 0xE4, 0x42, 0x8B, 0xB3, 0x47, 0x44, 0x68, 0x99, 0xD9, 0x78, 0x32, 0x15, 0x56, 0xB7, - 0x2F, 0x53, 0x26, 0xA6, 0x0E, 0x01, 0x27, 0xAF, 0x94, 0x17, 0x59, 0x26, 0x98, 0x53, 0xFC, 0xFF, - 0x7B, 0x70, 0x47, 0x0F, 0x8A, 0x6D, 0xFA, 0x86, 0xEA, 0xA2, 0x3E, 0x5C, 0x8C, 0x76, 0xCD, 0x70, - 0x28, 0x79, 0x87, 0xD4, 0xF0, 0x26, 0x3D, 0x26, 0x5A, 0xFC, 0xFC, 0xED, 0x43, 0xC3, 0xEA, 0x2C, - 0x72, 0x35, 0x99, 0xB9, 0x26, 0xBD, 0x8D, 0x72, 0x1A, 0x53, 0x63, 0xD6, 0xB2, 0xF4, 0x38, 0xC3, - 0x00, 0x26, 0xDC, 0x90, 0x43, 0x0C, 0x80, 0x15, 0x47, 0x40, 0xB5, 0xE3, 0x53, 0xA2, 0x81, 0x00, - 0x11, 0x14, 0x7F, 0x57, 0xED, 0x9B, 0x32, 0x6C, 0x3B, 0x29, 0x34, 0x48, 0xB0, 0xE4, 0x65, 0xD2, - 0xE4, 0x0F, 0xD3, 0x43, 0xC6, 0x97, 0x53, 0x02, 0x92, 0xC7, 0x98, 0x74, 0x28, 0x6D, 0x41, 0x55, - 0x97, 0xB9, 0x01, 0xC2, 0x00, 0x48, 0xC1, 0x49, 0xFD, 0xA2, 0x47, 0x21, 0x36, 0x55, 0x80, 0x00, - 0x08, 0x0D, 0x92, 0x8D, 0x83, 0x4C, 0x90, 0x31, 0x2F, 0xC0, 0xF3, 0x10, 0xAA, 0x73, 0xD0, 0x00, - 0xD0, 0xA5, 0x33, 0x01, 0x4C, 0xF9, 0x93, 0x3F, 0x78, 0x49, 0x50, 0x51, 0x59, 0xA3, 0x08, 0x76, - 0x92, 0x87, 0x10, 0x37, 0xE3, 0x08, 0x47, 0x91, 0x48, 0x5B, 0xF5, 0xD8, 0x51, 0x30, 0xF6, 0x86, - 0xF6, 0x4C, 0xBC, 0x50, 0x25, 0x76, 0x37, 0x15, 0x7F, 0xD8, 0x0A, 0xB2, 0xBC, 0x93, 0x89, 0xB9, - 0x08, 0xFF, 0xFB, 0x92, 0x64, 0xEE, 0x04, 0x43, 0xDA, 0x31, 0xC9, 0x53, 0x4C, 0x2C, 0xB0, 0x42, - 0x41, 0x39, 0x6A, 0x31, 0xE9, 0x24, 0x13, 0x74, 0xC1, 0x14, 0x0E, 0xE5, 0x2F, 0x40, 0xFC, 0x02, - 0xA7, 0x74, 0x27, 0xB0, 0x02, 0x8D, 0x19, 0xCC, 0x49, 0x4C, 0xCA, 0xA8, 0x36, 0x07, 0x00, 0x28, - 0xEA, 0x49, 0x65, 0x54, 0x2B, 0xF0, 0x13, 0x4E, 0xEC, 0xED, 0xBA, 0xC8, 0x52, 0xE8, 0xEF, 0xFA, - 0x17, 0x13, 0xF7, 0xF9, 0x8F, 0xF1, 0x4F, 0xF6, 0xEA, 0xFC, 0x75, 0x3A, 0x37, 0x22, 0xD6, 0x49, - 0x2D, 0x17, 0x39, 0xD0, 0x00, 0x00, 0x10, 0x2C, 0xC2, 0x9E, 0x00, 0x7D, 0x98, 0x93, 0x43, 0x99, - 0x1A, 0x20, 0x88, 0x7B, 0xEF, 0xFF, 0xFD, 0x6B, 0xFE, 0xBF, 0xEB, 0xD7, 0x35, 0xA8, 0xB7, 0xE8, - 0xA8, 0x18, 0xE8, 0xB4, 0x5C, 0x38, 0x74, 0xD0, 0x13, 0xBA, 0x37, 0x6D, 0x41, 0x2C, 0xAE, 0x93, - 0xB0, 0xDB, 0x77, 0x5D, 0xDC, 0xF0, 0x3C, 0xEB, 0xC0, 0x1C, 0x94, 0x7C, 0xC0, 0x42, 0xB3, 0x33, - 0x9E, 0xD2, 0xB1, 0x09, 0x23, 0x03, 0x03, 0x49, 0xD1, 0x8D, 0x1C, 0x0E, 0x32, 0x39, 0xB9, 0x1F, - 0x80, 0x87, 0x93, 0x08, 0x83, 0xCC, 0x2C, 0xF5, 0x30, 0xD0, 0x20, 0xDD, 0x00, 0x35, 0xA1, 0xF0, - 0xCF, 0x75, 0x0C, 0xC3, 0x53, 0x49, 0x57, 0x4B, 0xC1, 0x0B, 0x33, 0xF5, 0xC9, 0x30, 0xDB, 0x29, - 0x63, 0xA0, 0xA5, 0x2C, 0x89, 0xF9, 0x5B, 0x22, 0xA0, 0xA7, 0x2C, 0x3A, 0xD1, 0xA7, 0x61, 0xF5, - 0x49, 0x0F, 0xBC, 0xF0, 0x03, 0xFD, 0x2C, 0x5E, 0x50, 0x7D, 0x45, 0x94, 0xAF, 0xD8, 0xDB, 0xE9, - 0x01, 0xC2, 0xDA, 0x05, 0x0C, 0x18, 0xFB, 0xB2, 0x94, 0x19, 0x1B, 0x2B, 0xEB, 0x7F, 0x11, 0xFF, - 0x7C, 0xFC, 0xC6, 0xE3, 0x24, 0xD6, 0x79, 0x1A, 0x21, 0x27, 0xA8, 0x8C, 0x69, 0x92, 0xD6, 0xD7, - 0xCD, 0x59, 0x9E, 0xEB, 0xDB, 0x2C, 0x45, 0x74, 0xEE, 0xE5, 0x3F, 0x6D, 0x68, 0x14, 0x80, 0x00, - 0x00, 0x0B, 0x00, 0x0D, 0x8E, 0x5D, 0xC5, 0x52, 0xF3, 0x94, 0xC7, 0xE2, 0x43, 0xC8, 0x25, 0x04, - 0xB8, 0xA4, 0x2F, 0x17, 0x0B, 0x69, 0x89, 0x81, 0x15, 0xC1, 0x90, 0x22, 0x7F, 0xA3, 0xF7, 0x43, - 0x62, 0xC3, 0xC8, 0x06, 0x5E, 0x72, 0xB5, 0x24, 0x1E, 0x38, 0x81, 0x6D, 0x2D, 0xDB, 0xA0, 0x5D, - 0xAF, 0x4A, 0xF5, 0x33, 0xCE, 0x0E, 0x75, 0x31, 0x6D, 0x5D, 0xCC, 0xD9, 0xA6, 0x72, 0xF7, 0xF6, - 0x25, 0x20, 0x00, 0x01, 0x13, 0x29, 0xE3, 0x13, 0x5E, 0x46, 0x90, 0x74, 0x5E, 0x81, 0x10, 0x00, - 0x81, 0x44, 0xD7, 0xEB, 0x4C, 0x88, 0x2C, 0xCB, 0x04, 0xC3, 0x85, 0x0B, 0x05, 0xC6, 0x36, 0x12, - 0x90, 0xE6, 0x68, 0x42, 0x66, 0x65, 0x80, 0x10, 0x92, 0xDD, 0xA5, 0x88, 0x71, 0x35, 0x89, 0x4E, - 0x04, 0x20, 0x2E, 0xAC, 0x94, 0x7C, 0x3A, 0x52, 0x40, 0x1E, 0x74, 0x75, 0x32, 0x07, 0x1E, 0x88, - 0xC5, 0x41, 0x7C, 0xD0, 0x8A, 0xA9, 0xAF, 0x7D, 0x8E, 0x4C, 0x78, 0x15, 0x93, 0xD5, 0xC2, 0x82, - 0x61, 0xF1, 0xAD, 0xFF, 0xFB, 0x92, 0x64, 0xE0, 0x84, 0x03, 0x86, 0x2E, 0xC8, 0x33, 0x4C, 0x15, - 0x90, 0x35, 0x85, 0x29, 0xFC, 0x3C, 0x22, 0x1F, 0x90, 0xB8, 0xBB, 0x18, 0x2E, 0x65, 0x6D, 0x81, - 0x0B, 0x07, 0xE6, 0x74, 0x61, 0x26, 0x00, 0x6A, 0x86, 0x7F, 0xEA, 0x68, 0x68, 0x84, 0xFD, 0x2C, - 0xBF, 0xBB, 0xE2, 0x41, 0x8C, 0x8D, 0x5D, 0xE1, 0x44, 0x95, 0x8C, 0x36, 0x81, 0x8F, 0xFD, 0xBF, - 0xFE, 0x95, 0x75, 0xE8, 0xB9, 0x76, 0x5D, 0x14, 0xAF, 0x70, 0xC4, 0xC6, 0x00, 0x2E, 0x00, 0x4D, - 0xB7, 0x21, 0x28, 0xE8, 0xAE, 0xD5, 0x20, 0x4A, 0x91, 0xFC, 0x14, 0x2D, 0xEC, 0x10, 0x97, 0x69, - 0x20, 0x50, 0xD1, 0xC3, 0xCC, 0x45, 0xAC, 0x61, 0xE6, 0x96, 0x72, 0x4F, 0xB1, 0x92, 0x71, 0x46, - 0x2C, 0xC1, 0x36, 0x31, 0x29, 0xB9, 0x59, 0x09, 0x90, 0x72, 0xE5, 0x5C, 0xAB, 0x84, 0xEE, 0xBB, - 0xFF, 0x22, 0xAC, 0xC5, 0x8E, 0xEE, 0xFE, 0xCF, 0xD5, 0x90, 0x09, 0xC9, 0x2F, 0xD2, 0x98, 0x01, - 0x46, 0x1E, 0x29, 0x92, 0x18, 0x0E, 0x38, 0x5A, 0x93, 0x3D, 0xB4, 0x31, 0x11, 0x85, 0x26, 0xB1, - 0x46, 0x53, 0x91, 0x18, 0x26, 0x0E, 0x17, 0x08, 0x72, 0x03, 0x80, 0x40, 0x90, 0x92, 0x2F, 0xA3, - 0x82, 0xD1, 0x5E, 0x0F, 0xE5, 0x33, 0x4A, 0x9C, 0xE5, 0xBE, 0x99, 0x1D, 0x4D, 0xBB, 0xC2, 0x99, - 0x88, 0xC3, 0x4B, 0x32, 0x31, 0x7F, 0xF5, 0x34, 0x16, 0x61, 0xA4, 0x8C, 0x8F, 0x35, 0xE7, 0x04, - 0xE2, 0x4A, 0x94, 0x24, 0x8D, 0x96, 0x97, 0xB2, 0x5E, 0x8F, 0xFC, 0x26, 0x16, 0x5B, 0x66, 0x63, - 0x73, 0x7F, 0x4E, 0xCA, 0xCE, 0xEB, 0x04, 0x25, 0x4A, 0xDA, 0x47, 0x3A, 0xCF, 0x28, 0xD5, 0xE8, - 0x6E, 0x5C, 0x51, 0xB8, 0xF2, 0x45, 0x94, 0xED, 0x15, 0x00, 0xCF, 0xA5, 0xEB, 0x06, 0x40, 0x04, - 0x04, 0xA2, 0x4D, 0xC9, 0x83, 0xA9, 0x15, 0x4B, 0x00, 0x70, 0x96, 0x3E, 0x0B, 0x86, 0xD6, 0x46, - 0x08, 0xC2, 0x91, 0xD1, 0x9B, 0x46, 0xB3, 0xAB, 0xF8, 0xA2, 0x57, 0xF5, 0x16, 0x9C, 0x36, 0x2E, - 0x3F, 0x46, 0x5F, 0x46, 0xA3, 0xB5, 0xC4, 0x9E, 0xC0, 0x98, 0xC5, 0xD2, 0xD5, 0xAB, 0xB5, 0x8F, - 0xE4, 0xB8, 0xC2, 0x45, 0x93, 0x54, 0xDA, 0xB5, 0xEF, 0xDF, 0xFE, 0xEE, 0xFA, 0x6C, 0xF2, 0x0F, - 0xED, 0x02, 0xE8, 0xD2, 0xD0, 0xCE, 0x49, 0xCE, 0xCC, 0x58, 0x08, 0x2C, 0x44, 0x6C, 0x61, 0x0B, - 0x46, 0x2B, 0xC4, 0x6E, 0xE4, 0x46, 0x02, 0xF0, 0x19, 0x50, 0x62, 0x8A, 0xE6, 0x62, 0x30, 0x62, - 0x00, 0xA0, 0xAE, 0xD0, 0xCA, 0x33, 0x23, 0x61, 0x33, 0x71, 0xD0, 0xE2, 0x30, 0x12, 0xAD, 0x84, - 0xF7, 0x03, 0x04, 0x13, 0x06, 0xBA, 0x14, 0x69, 0x88, 0xC3, 0x9E, 0xE6, 0x60, 0xE2, 0xCE, 0x4A, - 0xA4, 0x60, 0x50, 0x3A, 0x52, 0xF0, 0x87, 0x00, 0xBE, 0x3B, 0x0E, 0x91, 0x6A, 0xAC, 0x7D, 0xB3, - 0x97, 0x34, 0x5A, 0x3C, 0x08, 0xE0, 0x4B, 0x9F, 0xE9, 0x76, 0x28, 0x07, 0x79, 0xD6, 0x9C, 0xB5, - 0xDE, 0x3F, 0x81, 0x11, 0xE3, 0xFF, 0xFB, 0x92, 0x64, 0xE8, 0x06, 0x03, 0xB1, 0x2F, 0x48, 0xBB, - 0x6C, 0x1C, 0xB0, 0x3D, 0xC1, 0x59, 0x7A, 0x04, 0x46, 0x00, 0x0E, 0x84, 0xF9, 0x27, 0x4D, 0x3C, - 0x4F, 0x41, 0x10, 0x12, 0x65, 0xA8, 0xC1, 0x95, 0x50, 0x87, 0xB9, 0xDF, 0x7B, 0xF7, 0x5B, 0xF5, - 0x85, 0xAA, 0x92, 0x2C, 0xD0, 0x49, 0x82, 0xC2, 0x30, 0xF1, 0x94, 0x0B, 0xCD, 0x89, 0x81, 0xD7, - 0xBD, 0xA9, 0x6C, 0xB7, 0x0D, 0x80, 0x07, 0x84, 0x05, 0x4C, 0x05, 0x5E, 0x39, 0x57, 0x8F, 0xA6, - 0x1A, 0x8A, 0xAD, 0x6E, 0xC8, 0xF4, 0xC5, 0xCE, 0xD4, 0xC0, 0x00, 0x00, 0x14, 0xAC, 0x76, 0xA1, - 0xAE, 0x4E, 0x10, 0xF3, 0xF5, 0x60, 0x59, 0x8B, 0x19, 0x75, 0x53, 0x39, 0x35, 0xA2, 0xD5, 0x89, - 0xF5, 0x95, 0xF7, 0x51, 0x77, 0xC8, 0x7C, 0x4E, 0xBE, 0x0C, 0x61, 0x0B, 0x9F, 0xEF, 0xAA, 0xCD, - 0xE7, 0x9F, 0x0D, 0x24, 0x14, 0x7C, 0xBC, 0x60, 0xB2, 0x84, 0xA0, 0x32, 0x6F, 0x1D, 0x16, 0x7D, - 0x88, 0xAB, 0xEA, 0x9B, 0xA1, 0x5D, 0x15, 0xA7, 0xBB, 0xA6, 0xAE, 0xD8, 0x03, 0x78, 0x26, 0x06, - 0x30, 0x64, 0x33, 0x4A, 0x91, 0x03, 0x1F, 0x33, 0xE3, 0x0D, 0xFB, 0xF5, 0x54, 0x38, 0x4A, 0x0D, - 0x03, 0xD3, 0x0A, 0x64, 0xD2, 0x4C, 0x2E, 0x99, 0x82, 0x20, 0x12, 0xF4, 0xCB, 0x92, 0x33, 0xB0, - 0x57, 0xA8, 0x92, 0x70, 0x10, 0xFA, 0xCB, 0x6C, 0x40, 0x60, 0xBE, 0x6F, 0x64, 0x3E, 0x07, 0x64, - 0xBE, 0xD5, 0x0E, 0xD0, 0x6A, 0x72, 0x7E, 0x18, 0x25, 0x81, 0x5C, 0x92, 0x35, 0xCA, 0x34, 0xEB, - 0x1B, 0x34, 0xD9, 0x64, 0x7E, 0xAF, 0xD0, 0x83, 0x81, 0xE1, 0x3F, 0x2B, 0x87, 0xDB, 0xFC, 0xFD, - 0x45, 0x83, 0xB7, 0x80, 0x67, 0x1A, 0x6E, 0xB8, 0xFB, 0xEC, 0x36, 0x48, 0x07, 0xE8, 0x55, 0x7F, - 0xEE, 0x17, 0xAB, 0x98, 0x52, 0xEB, 0x9D, 0xCF, 0xFE, 0xFF, 0xAA, 0xD6, 0x0A, 0x00, 0x60, 0x19, - 0x75, 0x7B, 0x84, 0xA9, 0xF4, 0x7D, 0x7A, 0x21, 0x95, 0xE1, 0xBB, 0x6C, 0x33, 0xFF, 0x5C, 0x35, - 0xDC, 0x5D, 0x67, 0x14, 0x34, 0xE9, 0xEC, 0xC9, 0xF1, 0x96, 0x0D, 0x1E, 0x74, 0x9B, 0x11, 0x8A, - 0xBE, 0xD6, 0x98, 0x02, 0xFD, 0x07, 0x55, 0xD8, 0x95, 0xD7, 0xE9, 0xBF, 0xD4, 0xE3, 0x29, 0x16, - 0x16, 0x35, 0x84, 0x03, 0x9D, 0x1B, 0x30, 0x10, 0x13, 0x07, 0x9F, 0x39, 0x48, 0xF3, 0x16, 0xA9, - 0x3E, 0x57, 0x83, 0x7B, 0x16, 0x33, 0x18, 0x73, 0x01, 0x18, 0x0A, 0xB0, 0x1E, 0xFB, 0xB9, 0xF2, - 0xA3, 0x9A, 0x88, 0x99, 0xA6, 0x05, 0x18, 0xC9, 0x01, 0x90, 0x83, 0x24, 0x5B, 0x39, 0x2A, 0x15, - 0x1A, 0x78, 0xBA, 0x00, 0x97, 0x82, 0x19, 0x13, 0x07, 0xD2, 0xA3, 0xA3, 0x77, 0x85, 0x36, 0x65, - 0xE2, 0x08, 0x13, 0x6C, 0x0C, 0x6E, 0xB2, 0x83, 0xAF, 0xA5, 0x88, 0xE0, 0xBC, 0x10, 0x2E, 0x4B, - 0x0E, 0x8A, 0x94, 0xCB, 0xB1, 0xF8, 0x58, 0x8E, 0x9C, 0x69, 0xA8, 0xD1, 0x82, 0x28, 0x31, 0xCD, - 0x97, 0x1D, 0x47, 0x90, 0x23, 0xE8, 0x62, 0xFF, 0xFB, 0x92, 0x64, 0xF1, 0x04, 0x04, 0x9F, 0x2F, - 0xC6, 0x0B, 0x6F, 0x2D, 0xA0, 0x42, 0xA4, 0x09, 0x49, 0x3C, 0x43, 0x86, 0x0E, 0x14, 0x81, 0x1E, - 0xAD, 0xE9, 0xE3, 0xC0, 0xC3, 0x0D, 0x28, 0xE4, 0x20, 0x0E, 0x1E, 0x93, 0xED, 0xB7, 0x1A, 0xC5, - 0x43, 0xDD, 0x76, 0xAC, 0x94, 0x6C, 0x64, 0x53, 0xD3, 0xCF, 0xE7, 0x2D, 0x60, 0xC5, 0x15, 0x9F, - 0xF1, 0x3F, 0xAF, 0x2C, 0x65, 0x47, 0xB3, 0x2F, 0xB3, 0x95, 0x95, 0xAF, 0x5F, 0xF6, 0xE7, 0xEB, - 0xE6, 0xF7, 0x1D, 0x65, 0x6F, 0xCF, 0xFD, 0x5A, 0xDF, 0x24, 0x6E, 0x20, 0x02, 0x2A, 0xBF, 0x9A, - 0xFD, 0xE2, 0xDD, 0x02, 0xDA, 0x2B, 0xE3, 0x9A, 0x1B, 0xBA, 0xC6, 0xDB, 0x3C, 0x9F, 0x7F, 0xC8, - 0x00, 0x8F, 0x91, 0xF3, 0x7D, 0x22, 0x0C, 0x08, 0xE2, 0xED, 0xB7, 0xD9, 0x2B, 0xB8, 0x80, 0xB8, - 0x2C, 0x49, 0x09, 0x66, 0xFA, 0xDA, 0xB8, 0xD5, 0xC8, 0xB1, 0x48, 0x8E, 0x50, 0x95, 0x6B, 0x50, - 0x02, 0x17, 0x12, 0xA4, 0xC9, 0xD4, 0x30, 0x83, 0x1B, 0x30, 0xB7, 0x8E, 0x6D, 0x63, 0xD2, 0xBB, - 0x7A, 0x29, 0xA9, 0x5F, 0x6C, 0x04, 0x00, 0x00, 0x04, 0x91, 0x75, 0xB7, 0x69, 0xC8, 0xFC, 0xB0, - 0x28, 0x42, 0x25, 0xCD, 0xAB, 0x81, 0x78, 0x1A, 0x71, 0x6C, 0xE1, 0x25, 0xEC, 0x86, 0xDF, 0xB4, - 0x15, 0x44, 0x44, 0xB7, 0x41, 0x01, 0x34, 0x60, 0xEA, 0x22, 0xB8, 0x16, 0x9C, 0x89, 0x3A, 0x56, - 0xB5, 0x4C, 0xE9, 0x06, 0xA2, 0x71, 0xB6, 0xDA, 0xD4, 0xFF, 0x84, 0x35, 0xB1, 0x93, 0x32, 0xF3, - 0xF3, 0x6B, 0x3F, 0xC4, 0xD7, 0x64, 0x4C, 0x64, 0x0B, 0x19, 0xAB, 0xBE, 0x28, 0xFE, 0x79, 0x56, - 0xFF, 0x5B, 0xF6, 0x6F, 0xDE, 0xE6, 0x54, 0xEE, 0x97, 0xB1, 0x8C, 0x7F, 0xDB, 0x6B, 0x09, 0x37, - 0xDE, 0x99, 0x68, 0x00, 0x00, 0x08, 0x06, 0x5B, 0x28, 0x03, 0x50, 0x84, 0xE1, 0xE8, 0x72, 0x2B, - 0x50, 0xE1, 0xC9, 0x21, 0x23, 0x02, 0xB0, 0xE4, 0x8A, 0x91, 0x0B, 0x56, 0xB5, 0xFF, 0xA4, 0x55, - 0x65, 0x2E, 0x48, 0xF4, 0x3C, 0xD8, 0xB9, 0x8B, 0x48, 0xDA, 0x36, 0x57, 0x1B, 0xD0, 0xFD, 0xF1, - 0x45, 0xA6, 0x17, 0x00, 0x0D, 0xA6, 0x54, 0x8D, 0x75, 0x81, 0x80, 0x00, 0x00, 0x00, 0x24, 0xB6, - 0x5B, 0x09, 0xDA, 0x53, 0x08, 0x08, 0x4B, 0x44, 0x48, 0x18, 0x80, 0xC1, 0x79, 0x1C, 0x52, 0x28, - 0x2C, 0x01, 0x98, 0x28, 0x19, 0x42, 0x82, 0x52, 0xBD, 0x3F, 0x94, 0xE0, 0x1A, 0x3A, 0x4E, 0x35, - 0x97, 0xE2, 0x37, 0x13, 0x28, 0x82, 0x5B, 0x36, 0x59, 0xFA, 0x1C, 0x9B, 0x26, 0x53, 0x09, 0xCD, - 0x10, 0xD6, 0x06, 0xF0, 0x38, 0xB1, 0xE9, 0xE6, 0x97, 0x49, 0xC8, 0xF2, 0xA5, 0x1B, 0xEB, 0xB9, - 0x14, 0xA5, 0x6E, 0xD3, 0x7D, 0xC2, 0x57, 0xDD, 0x25, 0x2E, 0x4A, 0xA2, 0xA3, 0xC9, 0xB4, 0x56, - 0x4E, 0x21, 0x5A, 0x40, 0x0E, 0x70, 0xA2, 0x2E, 0x78, 0xB1, 0xA1, 0xEE, 0x8A, 0x21, 0xF2, 0x19, - 0x17, 0x92, 0x11, 0x90, 0x63, 0x10, 0x05, 0xAE, 0xD4, 0xFF, 0xFB, 0x92, 0x64, 0xF4, 0x00, 0x04, - 0xC5, 0x27, 0xC5, 0x03, 0x6C, 0x1E, 0x82, 0x4B, 0x04, 0x6A, 0x1C, 0x3C, 0x23, 0x4F, 0x8B, 0x9C, - 0x81, 0x31, 0xAC, 0xB1, 0x2E, 0x40, 0xDB, 0x84, 0xA6, 0xB4, 0x16, 0x18, 0x10, 0xFB, 0x12, 0xB6, - 0x39, 0xB1, 0x5D, 0xF9, 0x44, 0x3E, 0xC0, 0x60, 0x00, 0x10, 0x56, 0xDB, 0x76, 0xDC, 0x1D, 0x4B, - 0x4A, 0x1F, 0x1D, 0x48, 0xC9, 0x12, 0x03, 0x60, 0x1B, 0x69, 0x5E, 0x33, 0x67, 0x1C, 0xCA, 0x4B, - 0x71, 0xB0, 0x73, 0x5E, 0xBE, 0x3C, 0x9E, 0x44, 0x48, 0xD9, 0xDE, 0xDF, 0x67, 0x98, 0x61, 0x53, - 0xC9, 0x0D, 0x3C, 0xA5, 0x33, 0x07, 0x81, 0x43, 0x97, 0xB0, 0x13, 0x5E, 0xA1, 0xFC, 0x24, 0x69, - 0x81, 0x06, 0x93, 0x3B, 0x1C, 0xFC, 0x51, 0x88, 0xDE, 0xA1, 0x88, 0x5C, 0x8A, 0xDF, 0x47, 0x65, - 0x69, 0xFA, 0xC1, 0x98, 0x66, 0x34, 0x4A, 0x11, 0xCF, 0x50, 0x15, 0x30, 0xC7, 0x01, 0x4F, 0x20, - 0xA9, 0xA7, 0xE0, 0x98, 0xA6, 0x8B, 0x86, 0xEA, 0x05, 0x80, 0xE6, 0x41, 0x59, 0xCE, 0x66, 0x61, - 0xD6, 0x0A, 0x9D, 0x0A, 0x0C, 0x25, 0x4C, 0x6C, 0xCC, 0x27, 0x39, 0x20, 0x41, 0x60, 0xE1, 0x80, - 0x68, 0x20, 0xD7, 0x91, 0x52, 0xC0, 0x28, 0x05, 0x77, 0x18, 0x96, 0x93, 0x99, 0xBE, 0x92, 0x35, - 0x95, 0x16, 0x55, 0xD2, 0x0A, 0x36, 0x05, 0x23, 0xAC, 0xFA, 0xD3, 0x38, 0x4F, 0xD4, 0x65, 0x91, - 0x38, 0xCE, 0x55, 0x0F, 0x2B, 0x90, 0x26, 0x81, 0xA7, 0x02, 0xB2, 0x0A, 0x4C, 0x36, 0xD6, 0x05, - 0x62, 0x5A, 0xD3, 0x4F, 0x4F, 0xFB, 0x17, 0x1A, 0xDA, 0x5A, 0x16, 0x9A, 0xB6, 0x73, 0x54, 0x96, - 0x7F, 0xE6, 0xBF, 0xFD, 0xCE, 0xAB, 0xB4, 0x88, 0x9A, 0x55, 0x55, 0xF5, 0x51, 0x78, 0x55, 0x57, - 0xED, 0x31, 0x3F, 0xAC, 0xBB, 0x6A, 0xBB, 0xF6, 0xEF, 0x2B, 0x47, 0xD3, 0x4B, 0xA9, 0x03, 0x55, - 0xC3, 0xD5, 0x57, 0xC2, 0x6F, 0xAA, 0x69, 0x0F, 0x03, 0xA6, 0x0A, 0xC0, 0x0F, 0xD9, 0x04, 0x87, - 0x37, 0xB8, 0x12, 0xA1, 0x72, 0x5A, 0x2F, 0x02, 0x25, 0x03, 0x62, 0x4F, 0xA5, 0x70, 0xE4, 0x49, - 0x4A, 0x62, 0xB5, 0x6B, 0xAA, 0xB8, 0xC0, 0xE1, 0xC3, 0x9E, 0x54, 0x0A, 0x54, 0x19, 0x11, 0x63, - 0x4E, 0xB1, 0x63, 0x5D, 0xC6, 0x9D, 0xF5, 0x11, 0x05, 0x5C, 0x25, 0x74, 0xD3, 0xDC, 0x0B, 0x1E, - 0x79, 0xE8, 0xB0, 0x76, 0x44, 0x4A, 0xB7, 0x48, 0x7E, 0xA6, 0x0A, 0xD9, 0x11, 0xBD, 0xFC, 0x1A, - 0x4C, 0x01, 0x02, 0xA1, 0xA9, 0xF8, 0x75, 0xC2, 0xE7, 0x32, 0x91, 0x8C, 0xF4, 0x1F, 0xD0, 0x85, - 0x78, 0x83, 0x08, 0x72, 0x8D, 0x7E, 0x49, 0x64, 0x5A, 0x92, 0x05, 0x50, 0x30, 0x1A, 0x8B, 0x84, - 0xBD, 0x11, 0x35, 0x07, 0x85, 0xA3, 0x4E, 0x73, 0x3C, 0x5A, 0x2E, 0x44, 0xE3, 0x4D, 0x85, 0xE6, - 0xCD, 0x1A, 0x2A, 0x2E, 0x37, 0x36, 0x68, 0xBB, 0x33, 0xA8, 0x89, 0xD4, 0x8B, 0x2D, 0x66, 0x4B, - 0x56, 0xEE, 0x9F, 0x01, 0x3D, 0x52, 0xDA, 0x3A, 0x87, 0xF2, 0xB9, 0xFF, 0xFB, 0x92, 0x64, 0xF7, - 0x04, 0x43, 0xC1, 0x23, 0xCA, 0x6B, 0x2C, 0x34, 0xB0, 0x4D, 0x24, 0x69, 0x9D, 0x30, 0x23, 0x6A, - 0x13, 0x24, 0xDD, 0x16, 0x2C, 0xE8, 0xCB, 0xC9, 0x12, 0x86, 0x64, 0x88, 0x27, 0xB0, 0x10, 0x2F, - 0xDB, 0xFF, 0xFE, 0x2A, 0x2C, 0x39, 0x0B, 0x00, 0x04, 0x62, 0xC8, 0x49, 0x89, 0x2E, 0xA5, 0x6A, - 0xC4, 0x84, 0xF6, 0x42, 0x24, 0x88, 0xA5, 0x21, 0xDA, 0x0F, 0xE4, 0x25, 0x43, 0x88, 0x52, 0xA7, - 0xB9, 0xA5, 0xCF, 0x5A, 0x5A, 0x7B, 0xF7, 0xAD, 0x82, 0x53, 0xA2, 0xA7, 0x64, 0xA5, 0x9E, 0xC4, - 0x96, 0xFE, 0x76, 0x76, 0xB7, 0x49, 0x89, 0x62, 0x5C, 0xED, 0xB9, 0xD9, 0x6F, 0xE7, 0x57, 0xB1, - 0x52, 0x2D, 0xAE, 0x1A, 0xFF, 0xA2, 0xE2, 0x59, 0x50, 0xFB, 0x72, 0x48, 0xBB, 0x0D, 0x1D, 0x80, - 0x68, 0xC0, 0x59, 0x70, 0x01, 0x24, 0x5F, 0xB1, 0x29, 0x53, 0xBC, 0xAA, 0xAB, 0x21, 0x2B, 0x99, - 0xD4, 0x6E, 0x03, 0x57, 0x32, 0x87, 0x29, 0xCA, 0x77, 0xAF, 0xDD, 0x7F, 0x7B, 0xA9, 0x74, 0x02, - 0xD7, 0x67, 0x7B, 0xCB, 0xF1, 0xAB, 0xB6, 0x6A, 0xD2, 0xF3, 0x2D, 0xD2, 0xCC, 0x2C, 0xB1, 0xA0, - 0x08, 0xA9, 0x92, 0x24, 0x2D, 0x72, 0xD4, 0x48, 0x5B, 0x63, 0x1E, 0xA8, 0x69, 0x5B, 0xD0, 0xC6, - 0x72, 0xB2, 0x95, 0x32, 0xE8, 0x6D, 0x15, 0x8C, 0xF5, 0xE6, 0x75, 0x64, 0xA0, 0x93, 0x21, 0xA5, - 0x6F, 0xD0, 0xDF, 0xD5, 0xB3, 0x29, 0x9D, 0x72, 0xCC, 0xAF, 0x99, 0xDB, 0x65, 0x2F, 0xBF, 0xFE, - 0xAA, 0xD9, 0xC7, 0x74, 0x7A, 0x9A, 0x87, 0x7F, 0x8B, 0x80, 0x0C, 0x29, 0x40, 0xBA, 0x10, 0xC7, - 0x1E, 0x3D, 0x62, 0x11, 0xE9, 0x13, 0xA0, 0x08, 0x06, 0x42, 0x52, 0x4B, 0x21, 0x0A, 0x41, 0x64, - 0x64, 0xB8, 0x58, 0x95, 0x38, 0x67, 0x11, 0x38, 0x4A, 0x77, 0x89, 0x7B, 0x3A, 0xCE, 0xF2, 0xDF, - 0xAB, 0xC2, 0x6E, 0xF4, 0x70, 0xED, 0x45, 0x57, 0xEA, 0x40, 0x76, 0x25, 0x1A, 0x1A, 0xB4, 0x35, - 0x56, 0xB9, 0x67, 0xFF, 0xFB, 0x72, 0x53, 0xDA, 0xC6, 0x11, 0xCB, 0x2A, 0x80, 0x01, 0x40, 0x02, - 0x99, 0x20, 0x80, 0x06, 0x0C, 0x99, 0xCC, 0x56, 0x6C, 0xF9, 0x1C, 0x92, 0xE7, 0x31, 0x19, 0x70, - 0x8B, 0xAA, 0x14, 0x26, 0x3C, 0x50, 0xC3, 0x8C, 0x32, 0x21, 0x87, 0x07, 0x86, 0x21, 0x2D, 0x33, - 0x3F, 0x46, 0x93, 0x00, 0x2D, 0x0C, 0x06, 0x81, 0x17, 0xB4, 0xBE, 0x2E, 0xC2, 0x97, 0x38, 0x32, - 0x44, 0x8E, 0x5E, 0x6C, 0x17, 0x70, 0x43, 0x5E, 0x82, 0xE0, 0x08, 0x19, 0x90, 0xBD, 0xB4, 0xD0, - 0xCC, 0xED, 0xEA, 0xF4, 0x51, 0xA6, 0x64, 0xC9, 0x8B, 0x9A, 0xDE, 0x46, 0x5D, 0x84, 0x01, 0x39, - 0xE6, 0x10, 0x4B, 0x3F, 0x68, 0x32, 0x28, 0xE3, 0x96, 0x8F, 0xB0, 0x54, 0xAD, 0x81, 0x03, 0x44, - 0x2B, 0x1B, 0xAB, 0x3D, 0xC9, 0xA9, 0xFB, 0x11, 0x2A, 0x4B, 0x58, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xF4, 0x54, 0x74, 0xC0, 0xE8, 0xB5, 0x09, 0xFC, 0x1B, 0x04, 0x80, 0x9C, 0xFF, 0xFB, 0x92, - 0x64, 0xE4, 0x0C, 0x02, 0x90, 0x24, 0xC0, 0x88, 0x6F, 0x30, 0xE0, 0x41, 0x82, 0x48, 0x32, 0x04, - 0xCC, 0x00, 0x0F, 0xB5, 0xB4, 0xDC, 0x2C, 0x15, 0x59, 0x80, 0xD4, 0x04, 0x1F, 0xE8, 0x14, 0x88, - 0x52, 0x1F, 0x00, 0x79, 0xC3, 0x2E, 0x8A, 0x28, 0xE2, 0x25, 0x85, 0xC4, 0x5E, 0x2F, 0x1A, 0x8A, - 0x00, 0x80, 0x01, 0xBE, 0x86, 0x6D, 0x83, 0x4C, 0x01, 0x16, 0x82, 0x12, 0x04, 0x36, 0x0C, 0x04, - 0x69, 0xA0, 0x81, 0x6B, 0x05, 0x21, 0x1B, 0x37, 0x82, 0xD0, 0x37, 0x46, 0x0B, 0x1A, 0x6A, 0x0E, - 0x15, 0x30, 0x14, 0x51, 0x66, 0x84, 0x2C, 0x1C, 0xA4, 0x18, 0x45, 0x8E, 0x84, 0x2A, 0x08, 0xF3, - 0x25, 0xA2, 0x7B, 0xDB, 0x93, 0x11, 0x94, 0xB4, 0x97, 0x11, 0xE6, 0x95, 0x38, 0xCB, 0xB6, 0x1E, - 0x44, 0xE6, 0x12, 0xD3, 0x13, 0xA9, 0x68, 0xBE, 0x52, 0xEA, 0xD5, 0xEA, 0xAD, 0x27, 0x5A, 0x81, - 0xF7, 0x7D, 0xA5, 0xAD, 0x65, 0x73, 0x6F, 0x07, 0x09, 0xD2, 0x5A, 0xD5, 0x19, 0x74, 0x35, 0x3C, - 0x4B, 0xFF, 0xFF, 0xDB, 0xFF, 0xFF, 0x85, 0x1F, 0x48, 0x88, 0x4A, 0x0B, 0x82, 0x21, 0xE1, 0xE1, - 0x49, 0xD3, 0xC2, 0xA5, 0xD4, 0x34, 0x02, 0x92, 0x06, 0x8E, 0x13, 0x26, 0x29, 0x60, 0x99, 0x36, - 0x02, 0xC5, 0x00, 0xD2, 0xE2, 0x97, 0x11, 0x37, 0x15, 0x5A, 0x55, 0x99, 0x79, 0x79, 0x75, 0x4B, - 0x1F, 0x0A, 0xA0, 0x15, 0x1D, 0x1D, 0x01, 0x8A, 0x13, 0x5D, 0xA1, 0x86, 0xC5, 0x26, 0x48, 0x9E, - 0xCE, 0x4A, 0xD9, 0x5B, 0x37, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDD, 0x4A, 0x12, 0x08, 0x49, - 0x8D, 0x4B, 0x12, 0x34, 0x46, 0x15, 0x89, 0x28, 0x88, 0x49, 0x42, 0xA1, 0x92, 0xC3, 0x68, 0xD2, - 0x7C, 0x71, 0x8E, 0x11, 0x1E, 0x28, 0x08, 0x71, 0x71, 0x9A, 0x8A, 0x26, 0x18, 0x12, 0xAE, 0x5A, - 0x0B, 0x72, 0x1E, 0x21, 0xA5, 0x90, 0xC6, 0x6D, 0x61, 0x4F, 0x2D, 0x1C, 0xAC, 0x88, 0x52, 0x25, - 0x1A, 0x87, 0x36, 0xA2, 0x57, 0x0B, 0x4F, 0x71, 0xEB, 0x97, 0xA8, 0x92, 0xE2, 0xA4, 0x08, 0x71, - 0x27, 0x02, 0x08, 0xC8, 0x12, 0xC0, 0x99, 0x2F, 0xE2, 0x1A, 0xB0, 0x41, 0x8C, 0xA2, 0xDC, 0x8B, - 0x2C, 0x2F, 0x73, 0x58, 0x3A, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xFF, - 0xFB, 0x92, 0x64, 0xFF, 0x84, 0x94, 0x80, 0x6C, 0xA9, 0xB3, 0x40, 0x8F, 0xB2, 0x67, 0xE3, 0xF5, - 0x05, 0x63, 0x59, 0x06, 0x0A, 0x1D, 0xB0, 0x90, 0x04, 0x80, 0xFE, 0xC9, 0x31, 0x10, 0xD1, 0x18, - 0x94, 0xBC, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x10, 0xD5, - 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x41, 0x8F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, - 0x20, 0x10, 0x00, 0x24, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, - 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, - 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, - 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, - 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, - 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, - 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, - 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, - 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, - 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, - 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, - 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x90, 0x64, 0x41, - 0x0F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, - 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, - 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, - 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, - 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, - 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, - 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, - 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, - 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, - 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, - 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x08, - 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, 0x20, 0x00, - 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, 0x00, 0x00, - 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, 0x00, 0x00, - 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x4C, 0x41, 0x4D, 0x45, 0x33, 0x2E, 0x31, 0x30, 0x30, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFB, 0x92, 0x64, 0x40, 0x8F, 0xF0, 0x00, 0x00, 0x69, - 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0D, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xA4, 0x00, - 0x00, 0x00, 0x20, 0x00, 0x00, 0x34, 0x80, 0x00, 0x00, 0x04, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, - 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, -}; -static const unsigned kAllahAkbarMp3Size = 85512; -// END_EMBEDDED_NOTIFICATION_SOUND +// Notification sound is downloaded once to %APPDATA%\PrayerTray\audio\ +// from the GitHub repo (keeps this Windhawk single-file mod small). + +constexpr unsigned kNotificationSoundMinBytes = 1000; std::wstring GetNotificationSoundPath() { auto base = GetAppDataPrayerTrayPath(); @@ -7321,10 +1975,6 @@ std::wstring GetNotificationSoundPath() { } bool EnsureNotificationSoundFile() { - if (kAllahAkbarMp3Size == 0) { - Wh_Log(L"Notification sound missing embedded audio"); - return false; - } auto path = GetNotificationSoundPath(); if (path.empty()) { Wh_Log(L"Notification sound path unavailable"); @@ -7339,18 +1989,24 @@ bool EnsureNotificationSoundFile() { ULARGE_INTEGER size{}; size.HighPart = attrs.nFileSizeHigh; size.LowPart = attrs.nFileSizeLow; - if (size.QuadPart == kAllahAkbarMp3Size) { + if (size.QuadPart >= kNotificationSoundMinBytes) { return true; } } + auto body = HttpGetUtf8( + L"https://raw.githubusercontent.com/n0tmar/PrayerTray/main/windhawk/audio/allah-akbar.mp3"); + if (!body || body->size() < kNotificationSoundMinBytes) { + Wh_Log(L"Notification sound download failed"); + return false; + } + std::ofstream out(path.c_str(), std::ios::binary | std::ios::trunc); if (!out) { Wh_Log(L"Notification sound write failed"); return false; } - out.write(reinterpret_cast(kAllahAkbarMp3), - static_cast(kAllahAkbarMp3Size)); + out.write(body->data(), static_cast(body->size())); if (!out) { Wh_Log(L"Notification sound write incomplete"); return false; @@ -7609,11 +2265,21 @@ void ShowContextMenu(HWND anchor) { AppendMenuW(g_contextMenu, MF_STRING, kCmdShowMenu + 100, Loc(L"Tray_Settings").c_str()); POINT pt{}; GetCursorPos(&pt); - SetForegroundWindow(g_messageHwnd ? g_messageHwnd : anchor); + // Message-only windows are unreliable TrackPopupMenu owners on Win11. + HWND owner = FindCurrentProcessTaskbarWnd(); + if (!owner) { + owner = anchor; + } + if (!owner) { + owner = g_messageHwnd; + } + if (!owner) { + return; + } + SetForegroundWindow(owner); const UINT cmd = TrackPopupMenu(g_contextMenu, TPM_RIGHTBUTTON | TPM_RETURNCMD, - pt.x, pt.y, 0, g_messageHwnd ? g_messageHwnd : anchor, - nullptr); - PostMessageW(g_messageHwnd ? g_messageHwnd : anchor, WM_NULL, 0, 0); + pt.x, pt.y, 0, owner, nullptr); + PostMessageW(owner, WM_NULL, 0, 0); if (cmd) { DispatchCommand(static_cast(cmd)); } @@ -7631,7 +2297,8 @@ void DispatchCommand(int commandId) { ShowFlyout(); break; case kCmdShowMenu: - ShowContextMenu(g_win10OverlayHwnd ? g_win10OverlayHwnd : g_messageHwnd); + ShowContextMenu(g_win10OverlayHwnd ? g_win10OverlayHwnd + : FindCurrentProcessTaskbarWnd()); break; case kCmdRefreshLocation: RequestRefresh(true); @@ -8103,11 +2770,8 @@ bool IsSlotRootAlive() { g_slotInjected = false; return false; } - // Orphaned after tray XAML rebuild — demote so inject/backoff can recover. - if (!g_slotRoot.XamlRoot()) { - g_slotInjected = false; - return false; - } + // Do not require XamlRoot() here — it can be null for a moment after + // inject / during tray rebuild, and demoting then removes a live slot. return true; } catch (...) { g_slotInjected = false; @@ -8127,6 +2791,7 @@ void ApplySlotButtonVisualState() { void ResetSlotButtonVisualState() { g_slotPointerOver = false; g_slotPointerPressed = false; + g_slotRightPressed = false; ApplySlotButtonVisualState(); } @@ -8159,6 +2824,11 @@ void ApplyWin11SlotContent(const DisplayContent& content) { } return; } + // Always keep the button interactive when content is shown (recovers from + // a previous hide that left IsHitTestVisible false). + root.Visibility(Visibility::Visible); + root.Opacity(1.0); + root.IsHitTestVisible(true); if (!changed) return; const auto brush = Media::SolidColorBrush(ParseColor(content.color)); top.Text(content.top); @@ -8189,10 +2859,12 @@ void AttachSlotInteractions(FrameworkElement slotRoot) { button.PointerExited([](auto&, Input::PointerRoutedEventArgs const&) { g_slotPointerOver = false; g_slotPointerPressed = false; + g_slotRightPressed = false; ApplySlotButtonVisualState(); }); button.Click([](auto&, RoutedEventArgs const&) { DispatchCommand(kCmdShowFlyout); }); button.RightTapped([](auto&, Input::RightTappedRoutedEventArgs const& args) { + g_slotRightPressed = false; DispatchCommand(kCmdShowMenu); args.Handled(true); }); @@ -8201,16 +2873,26 @@ void AttachSlotInteractions(FrameworkElement slotRoot) { auto element = sender.try_as(); if (!element) return; auto props = args.GetCurrentPoint(element).Properties(); - if (props.IsRightButtonPressed() || props.IsLeftButtonPressed()) { + if (props.IsLeftButtonPressed()) { g_slotPointerOver = true; g_slotPointerPressed = true; ApplySlotButtonVisualState(); - if (props.IsRightButtonPressed()) args.Handled(true); + } + // Do not mark right-button as Handled here — that suppresses RightTapped. + if (props.IsRightButtonPressed()) { + g_slotPointerOver = true; + g_slotRightPressed = true; + ApplySlotButtonVisualState(); } }); - button.PointerReleased([](auto&, Input::PointerRoutedEventArgs const&) { + button.PointerReleased([](auto&, Input::PointerRoutedEventArgs const& args) { g_slotPointerPressed = false; ApplySlotButtonVisualState(); + // Fallback if RightTapped is eaten by the tray host. + if (g_slotRightPressed.exchange(false)) { + DispatchCommand(kCmdShowMenu); + args.Handled(true); + } }); } @@ -8425,11 +3107,13 @@ bool RunFromWindowThread(HWND hWnd, RunFromWindowThreadProc_t proc, void* param) if (!hook) return false; Param p{proc, param}; DWORD_PTR result = 0; - const BOOL sent = SendMessageTimeoutW( - hWnd, msg, 0, reinterpret_cast(&p), - SMTO_ABORTIFHUNG | SMTO_NORMAL, kRunFromWindowTimeoutMs, &result); + // Do not use SMTO_ABORTIFHUNG — tray layout often looks busy and aborted updates. + if (!SendMessageTimeoutW(hWnd, msg, 0, reinterpret_cast(&p), SMTO_NORMAL, + kRunFromWindowTimeoutMs, &result)) { + SendMessageW(hWnd, msg, 0, reinterpret_cast(&p)); + } UnhookWindowsHookEx(hook); - return sent != FALSE; + return true; } HWND FindCurrentProcessTaskbarWnd() { From d6ae160e011c8e3b1a1b12153082a09c5df6509d Mon Sep 17 00:00:00 2001 From: omaralhami Date: Sat, 18 Jul 2026 02:55:20 +0300 Subject: [PATCH 04/10] Update PrayerTray to 2.1.2 (Cursor-free) --- mods/prayertray.wh.cpp | 46 +++++++++++++----------------------------- 1 file changed, 14 insertions(+), 32 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index f117e2df28..3c8e9422c3 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.0.12 +// @version 2.1.2 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -99,7 +99,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.0.12" +#define WH_MOD_VERSION L"2.1.2" #endif #include @@ -157,6 +157,9 @@ constexpr double kClusterDistanceKm = 80.0; constexpr int kScheduleRefreshIntervalMs = 15 * 60 * 1000; constexpr int kGeoAccessTimeoutMs = 8000; constexpr int kRunFromWindowTimeoutMs = 3000; +constexpr wchar_t kNotificationSoundUrl[] = + L"https://raw.githubusercontent.com/n0tmar/PrayerTray/main/windhawk/audio/allah-akbar.mp3"; +constexpr unsigned kNotificationSoundBytes = 85512; enum class PrayerName { Fajr, Dhuhr, Asr, Maghrib, Isha, Count }; @@ -277,9 +280,6 @@ int g_lastOverlayY = 0; int g_lastOverlayW = 0; int g_lastOverlayH = 0; bool g_lastOverlayShown = false; -using FrameworkElementLoadedEventRevoker = winrt::impl::event_revoker< - IFrameworkElement, &winrt::impl::abi::type::remove_Loaded>; -std::list g_loadedRevokers; std::list> g_observedElements; Controls::TextBlock g_topTextBlock{nullptr}; Controls::TextBlock g_bottomTextBlock{nullptr}; @@ -300,7 +300,6 @@ std::wstring g_lastAppliedColor; constexpr int kCmdShowFlyout = 1; constexpr int kCmdShowMenu = 2; constexpr int kCmdRefreshLocation = 3; -constexpr int kCmdToggleWidget = 4; constexpr UINT WM_PT_REFRESH = WM_APP + 1; constexpr UINT WM_PT_UI_TICK = WM_APP + 2; constexpr UINT WM_PT_HIDE_FLYOUT = WM_APP + 3; @@ -1961,26 +1960,17 @@ DisplayContent FormatTaskbarDisplay() { return content; } -// Notification sound is downloaded once to %APPDATA%\PrayerTray\audio\ -// from the GitHub repo (keeps this Windhawk single-file mod small). - -constexpr unsigned kNotificationSoundMinBytes = 1000; - std::wstring GetNotificationSoundPath() { - auto base = GetAppDataPrayerTrayPath(); - if (base.empty()) { - return L""; - } - return base + L"\\audio\\allah-akbar.mp3"; + const auto base = GetAppDataPrayerTrayPath(); + return base.empty() ? L"" : base + L"\\audio\\allah-akbar.mp3"; } bool EnsureNotificationSoundFile() { - auto path = GetNotificationSoundPath(); + const auto path = GetNotificationSoundPath(); if (path.empty()) { - Wh_Log(L"Notification sound path unavailable"); return false; } - auto base = GetAppDataPrayerTrayPath(); + const auto base = GetAppDataPrayerTrayPath(); CreateDirectoryW(base.c_str(), nullptr); CreateDirectoryW((base + L"\\audio").c_str(), nullptr); @@ -1989,14 +1979,13 @@ bool EnsureNotificationSoundFile() { ULARGE_INTEGER size{}; size.HighPart = attrs.nFileSizeHigh; size.LowPart = attrs.nFileSizeLow; - if (size.QuadPart >= kNotificationSoundMinBytes) { + if (size.QuadPart == kNotificationSoundBytes) { return true; } } - auto body = HttpGetUtf8( - L"https://raw.githubusercontent.com/n0tmar/PrayerTray/main/windhawk/audio/allah-akbar.mp3"); - if (!body || body->size() < kNotificationSoundMinBytes) { + const auto body = HttpGetUtf8(kNotificationSoundUrl); + if (!body || body->size() != kNotificationSoundBytes) { Wh_Log(L"Notification sound download failed"); return false; } @@ -2007,11 +1996,7 @@ bool EnsureNotificationSoundFile() { return false; } out.write(body->data(), static_cast(body->size())); - if (!out) { - Wh_Log(L"Notification sound write incomplete"); - return false; - } - return true; + return static_cast(out); } void PlayNotificationSound() { @@ -2029,9 +2014,7 @@ void PlayNotificationSound() { return; } } - // MCI volume is 0–1000; match the old app's ~12% level. - mciSendStringW(L"setaudio prayertray_notify volume to 120", nullptr, 0, - nullptr); + mciSendStringW(L"setaudio prayertray_notify volume to 120", nullptr, 0, nullptr); if (mciSendStringW(L"play prayertray_notify", nullptr, 0, nullptr) != 0) { Wh_Log(L"Notification sound play failed"); } @@ -3438,7 +3421,6 @@ void ClearWin11SlotOnUiThread(void*) { } } catch (...) { } - g_loadedRevokers.clear(); g_observedElements.clear(); g_slotRoot = nullptr; g_slotButton = nullptr; From 1cefb6411e724ea2e17b80c48ce75e400faf06e2 Mon Sep 17 00:00:00 2001 From: omaralhami Date: Sat, 18 Jul 2026 06:12:30 +0300 Subject: [PATCH 05/10] Update PrayerTray to 2.1.4 --- mods/prayertray.wh.cpp | 100 ++++++++++++++++++++++++++++++++++------- 1 file changed, 85 insertions(+), 15 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index 3c8e9422c3..0e78939c9e 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.1.2 +// @version 2.1.4 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -99,7 +99,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.1.2" +#define WH_MOD_VERSION L"2.1.4" #endif #include @@ -271,7 +271,7 @@ int g_notificationActiveDateKey = 0; std::atomic g_taskbarViewDllLoaded; std::atomic g_slotInjected; std::atomic g_applySlotAttempts; -std::atomic g_injectRetryMs{400}; +std::atomic g_injectRetryMs{100}; std::atomic g_lastMeasureInjectAttemptMs{0}; int g_lastUiTimerIntervalMs = -1; bool g_hasOverlayPlacement = false; @@ -2213,8 +2213,56 @@ void MaybeRequestScheduleRefresh() { } } +std::wstring FindWindhawkExePath() { + wchar_t buffer[MAX_PATH]{}; + + // Default install locations. + const wchar_t* candidates[] = { + L"%ProgramFiles%\\Windhawk\\windhawk.exe", + L"%ProgramFiles(x86)%\\Windhawk\\windhawk.exe", + L"%LocalAppData%\\Programs\\Windhawk\\windhawk.exe", + }; + for (const wchar_t* pattern : candidates) { + DWORD n = ExpandEnvironmentStringsW(pattern, buffer, MAX_PATH); + if (n > 0 && n < MAX_PATH && GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES) { + return buffer; + } + } + + // Uninstall registry key often has the install folder. + HKEY key = nullptr; + if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, + L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Windhawk", + 0, KEY_READ | KEY_WOW64_64KEY, &key) == ERROR_SUCCESS) { + DWORD type = 0; + DWORD size = sizeof(buffer); + if (RegQueryValueExW(key, L"InstallLocation", nullptr, &type, + reinterpret_cast(buffer), &size) == ERROR_SUCCESS && + type == REG_SZ) { + std::wstring path = buffer; + if (!path.empty() && path.back() != L'\\') { + path += L'\\'; + } + path += L"windhawk.exe"; + if (GetFileAttributesW(path.c_str()) != INVALID_FILE_ATTRIBUTES) { + RegCloseKey(key); + return path; + } + } + RegCloseKey(key); + } + return L""; +} + void OpenWindhawkSettings() { - ShellExecuteW(nullptr, L"open", L"windhawk:", nullptr, nullptr, SW_SHOWNORMAL); + // Do NOT use windhawk: — that opens the code editor (VSCodium), not the + // mod manager. Launch Windhawk.exe for the real UI. + const auto exe = FindWindhawkExePath(); + if (!exe.empty()) { + ShellExecuteW(nullptr, L"open", exe.c_str(), nullptr, nullptr, SW_SHOWNORMAL); + return; + } + Wh_Log(L"Windhawk.exe not found"); } // Forward declarations @@ -2980,7 +3028,7 @@ bool EnsurePrayerTraySlotInTrayGrid(Controls::Grid trayGrid) { g_slotParentGrid = trayGrid; g_slotInjected = true; g_hasAppliedContent = false; - g_injectRetryMs = 400; + g_injectRetryMs = 100; AttachSlotInteractions(slotElement); return true; } @@ -3010,7 +3058,7 @@ bool EnsurePrayerTraySlot(FrameworkElement mainStack) { g_bottomTextBlock = FindTextBlockByName(slotButton, L"PrayerTrayBottom"); g_slotInjected = true; g_hasAppliedContent = false; - g_injectRetryMs = 400; + g_injectRetryMs = 100; AttachSlotInteractions(slotButton); return true; } @@ -3124,7 +3172,7 @@ void ApplyWin11FromThread(SlotApplyParam* param) { try { if (IsSlotRootAlive()) { ApplyWin11SlotContent(content); - g_injectRetryMs = 400; + g_injectRetryMs = 100; return; } } catch (...) { @@ -3151,15 +3199,16 @@ void ApplyWin11FromThread(SlotApplyParam* param) { try { if (IsSlotRootAlive()) { ApplyWin11SlotContent(content); - g_injectRetryMs = 400; + g_injectRetryMs = 100; return; } } catch (...) { g_slotInjected = false; } if (!injected) { - const int next = std::min(3000, std::max(400, g_injectRetryMs.load() * 2)); - g_injectRetryMs = next; + // Stay aggressive at first (100→200→400), then back off to 1.5s max. + const int cur = g_injectRetryMs.load(); + g_injectRetryMs = std::min(1500, std::max(100, cur * 2)); } } catch (...) { g_slotInjected = false; @@ -3248,7 +3297,8 @@ winrt::Windows::Foundation::Size WINAPI SystemTrayFrame_MeasureOverride_Hook( } const ULONGLONG now = GetTickCount64(); const ULONGLONG last = g_lastMeasureInjectAttemptMs.load(); - if (now - last < 1000) { + // Fast retries right after enable; still avoid fighting every layout pass. + if (now - last < 200) { return result; } g_lastMeasureInjectAttemptMs = now; @@ -3344,6 +3394,10 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara RepositionWin10Overlay(); } else if (wParam == 4) { RequestRefresh(false); + } else if (wParam == 5 || wParam == 6 || wParam == 7) { + // One-shot startup inject retries. + KillTimer(hWnd, wParam); + ApplyEngineToBackends(); } return 0; case WM_PT_UI_TICK: @@ -3459,6 +3513,13 @@ void ShutdownUi() { BOOL Wh_ModInit() { Wh_Log(L">"); + // Folder-window explorers also match @include explorer.exe but have no + // taskbar. Loading there races the shell explorer and delays the slot. + if (!FindCurrentProcessTaskbarWnd()) { + Wh_Log(L"No Shell_TrayWnd in this process — skipping (not shell explorer)"); + return FALSE; + } + LoadSettings(); SelectBackend(); EnsureMessageWindow(); @@ -3473,13 +3534,15 @@ BOOL Wh_ModInit() { WindhawkUtils::SetFunctionHook(pLoad, LoadLibraryExW_Hook, &LoadLibraryExW_Original); } } + + // Cache first so the slot has text immediately; network refresh is async. + BootstrapFromCache(); + g_injectRetryMs = 100; + g_uiTimerIntervalMs = 100; StartTimers(); UpdateTrayIcon(); ApplyEngineToBackends(); - if (BootstrapFromCache()) { - ApplyEngineToBackends(); - } - RequestRefresh(); + RequestRefresh(false); return TRUE; } @@ -3492,7 +3555,14 @@ void Wh_ModAfterInit() { } } } + // Burst a few applies after hooks settle — first appearance should be quick. ApplyEngineToBackends(); + if (g_messageHwnd) { + PostMessageW(g_messageHwnd, WM_PT_UI_TICK, 0, 0); + SetTimer(g_messageHwnd, 5, 150, nullptr); + SetTimer(g_messageHwnd, 6, 400, nullptr); + SetTimer(g_messageHwnd, 7, 900, nullptr); + } } void Wh_ModBeforeUninit() { From 6ff130c3c6d5f2febb1babb2405392dfa08d8300 Mon Sep 17 00:00:00 2001 From: omaralhami Date: Sat, 18 Jul 2026 06:21:30 +0300 Subject: [PATCH 06/10] Update PrayerTray to 2.1.5 --- mods/prayertray.wh.cpp | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index 0e78939c9e..3c52ff6656 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.1.4 +// @version 2.1.5 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -99,7 +99,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.1.4" +#define WH_MOD_VERSION L"2.1.5" #endif #include @@ -3513,13 +3513,6 @@ void ShutdownUi() { BOOL Wh_ModInit() { Wh_Log(L">"); - // Folder-window explorers also match @include explorer.exe but have no - // taskbar. Loading there races the shell explorer and delays the slot. - if (!FindCurrentProcessTaskbarWnd()) { - Wh_Log(L"No Shell_TrayWnd in this process — skipping (not shell explorer)"); - return FALSE; - } - LoadSettings(); SelectBackend(); EnsureMessageWindow(); @@ -3535,7 +3528,8 @@ BOOL Wh_ModInit() { } } - // Cache first so the slot has text immediately; network refresh is async. + // Never bail out of Wh_ModInit if Shell_TrayWnd is briefly missing (explorer + // restart / enable race). Slot inject already no-ops until the tray exists. BootstrapFromCache(); g_injectRetryMs = 100; g_uiTimerIntervalMs = 100; From d4f49f9a316d7f69e98a9b586eb316735469ccb8 Mon Sep 17 00:00:00 2001 From: omaralhami Date: Sat, 18 Jul 2026 03:34:57 +0300 Subject: [PATCH 07/10] Update PrayerTray to 2.1.6 --- mods/prayertray.wh.cpp | 78 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 76 insertions(+), 2 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index 3c52ff6656..5b1097348e 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.1.5 +// @version 2.1.6 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -99,7 +99,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.1.5" +#define WH_MOD_VERSION L"2.1.6" #endif #include @@ -157,6 +157,7 @@ constexpr double kClusterDistanceKm = 80.0; constexpr int kScheduleRefreshIntervalMs = 15 * 60 * 1000; constexpr int kGeoAccessTimeoutMs = 8000; constexpr int kRunFromWindowTimeoutMs = 3000; +constexpr int kExplorerRestartCooldownSec = 20; constexpr wchar_t kNotificationSoundUrl[] = L"https://raw.githubusercontent.com/n0tmar/PrayerTray/main/windhawk/audio/allah-akbar.mp3"; constexpr unsigned kNotificationSoundBytes = 85512; @@ -2279,6 +2280,74 @@ void DestroyWin10Overlay(); void RemoveTrayIcon(); HWND FindCurrentProcessTaskbarWnd(); +bool SlotUiReady() { + if (g_backend.load() == TaskbarBackend::Win11Xaml) { + return g_slotInjected.load() && g_slotRoot; + } + return g_win10OverlayHwnd != nullptr; +} + +bool ClaimExplorerRestart() { + const auto base = GetAppDataPrayerTrayPath(); + if (base.empty()) { + return false; + } + CreateDirectoryW(base.c_str(), nullptr); + const std::wstring flag = base + L"\\explorer-restart.flag"; + + WIN32_FILE_ATTRIBUTE_DATA attrs{}; + if (GetFileAttributesExW(flag.c_str(), GetFileExInfoStandard, &attrs)) { + FILETIME nowFt{}; + GetSystemTimeAsFileTime(&nowFt); + ULARGE_INTEGER now{}, then{}; + now.LowPart = nowFt.dwLowDateTime; + now.HighPart = nowFt.dwHighDateTime; + then.LowPart = attrs.ftLastWriteTime.dwLowDateTime; + then.HighPart = attrs.ftLastWriteTime.dwHighDateTime; + const ULONGLONG ageSec = (now.QuadPart - then.QuadPart) / 10000000ULL; + if (ageSec < static_cast(kExplorerRestartCooldownSec)) { + Wh_Log(L"Explorer restart skipped (cooldown %llu s)", ageSec); + return false; + } + } + + std::ofstream out(flag.c_str(), std::ios::trunc); + out << "1"; + return static_cast(out); +} + +void ScheduleExplorerRestart() { + // Detached helper so we don't kill this explorer mid-call. + wchar_t cmd[] = + L"cmd.exe /d /c \"ping -n 2 127.0.0.1 >nul & " + L"taskkill /f /im explorer.exe >nul 2>&1 & start explorer.exe\""; + STARTUPINFOW si{}; + si.cb = sizeof(si); + PROCESS_INFORMATION pi{}; + if (!CreateProcessW(nullptr, cmd, nullptr, nullptr, FALSE, CREATE_NO_WINDOW, + nullptr, nullptr, &si, &pi)) { + Wh_Log(L"Failed to schedule explorer restart (%u)", GetLastError()); + return; + } + CloseHandle(pi.hThread); + CloseHandle(pi.hProcess); + Wh_Log(L"Scheduled explorer restart so the taskbar slot can inject"); +} + +void MaybeRestartExplorerForSlot() { + ApplyEngineToBackends(); + if (SlotUiReady()) { + return; + } + if (!FindCurrentProcessTaskbarWnd()) { + // Folder explorers have no tray — don't kill the shell for them. + return; + } + if (!ClaimExplorerRestart()) { + return; + } + ScheduleExplorerRestart(); +} void EnsureContextMenu() { if (g_contextMenu) return; @@ -3398,6 +3467,9 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara // One-shot startup inject retries. KillTimer(hWnd, wParam); ApplyEngineToBackends(); + } else if (wParam == 8) { + KillTimer(hWnd, wParam); + MaybeRestartExplorerForSlot(); } return 0; case WM_PT_UI_TICK: @@ -3556,6 +3628,8 @@ void Wh_ModAfterInit() { SetTimer(g_messageHwnd, 5, 150, nullptr); SetTimer(g_messageHwnd, 6, 400, nullptr); SetTimer(g_messageHwnd, 7, 900, nullptr); + // If the slot still isn't there after retries, restart Explorer once. + SetTimer(g_messageHwnd, 8, 2500, nullptr); } } From 5aabd0c4c8fda909144f56cedabe58eb15b721be Mon Sep 17 00:00:00 2001 From: omaralhami Date: Sat, 18 Jul 2026 03:41:33 +0300 Subject: [PATCH 08/10] Update PrayerTray to 2.1.7 --- mods/prayertray.wh.cpp | 48 +++++++++++++++++++++++------------------- 1 file changed, 26 insertions(+), 22 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index 5b1097348e..c975866217 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.1.6 +// @version 2.1.7 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -99,7 +99,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.1.6" +#define WH_MOD_VERSION L"2.1.7" #endif #include @@ -157,7 +157,6 @@ constexpr double kClusterDistanceKm = 80.0; constexpr int kScheduleRefreshIntervalMs = 15 * 60 * 1000; constexpr int kGeoAccessTimeoutMs = 8000; constexpr int kRunFromWindowTimeoutMs = 3000; -constexpr int kExplorerRestartCooldownSec = 20; constexpr wchar_t kNotificationSoundUrl[] = L"https://raw.githubusercontent.com/n0tmar/PrayerTray/main/windhawk/audio/allah-akbar.mp3"; constexpr unsigned kNotificationSoundBytes = 85512; @@ -2287,7 +2286,7 @@ bool SlotUiReady() { return g_win10OverlayHwnd != nullptr; } -bool ClaimExplorerRestart() { +bool ClaimExplorerRestartOnce() { const auto base = GetAppDataPrayerTrayPath(); if (base.empty()) { return false; @@ -2295,25 +2294,26 @@ bool ClaimExplorerRestart() { CreateDirectoryW(base.c_str(), nullptr); const std::wstring flag = base + L"\\explorer-restart.flag"; - WIN32_FILE_ATTRIBUTE_DATA attrs{}; - if (GetFileAttributesExW(flag.c_str(), GetFileExInfoStandard, &attrs)) { - FILETIME nowFt{}; - GetSystemTimeAsFileTime(&nowFt); - ULARGE_INTEGER now{}, then{}; - now.LowPart = nowFt.dwLowDateTime; - now.HighPart = nowFt.dwHighDateTime; - then.LowPart = attrs.ftLastWriteTime.dwLowDateTime; - then.HighPart = attrs.ftLastWriteTime.dwHighDateTime; - const ULONGLONG ageSec = (now.QuadPart - then.QuadPart) / 10000000ULL; - if (ageSec < static_cast(kExplorerRestartCooldownSec)) { - Wh_Log(L"Explorer restart skipped (cooldown %llu s)", ageSec); - return false; - } + // CREATE_NEW: atomic one-shot. If the flag already exists, never restart again + // until the mod is disabled (flag cleared in Wh_ModBeforeUninit). + HANDLE h = CreateFileW(flag.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_NEW, + FILE_ATTRIBUTE_NORMAL, nullptr); + if (h == INVALID_HANDLE_VALUE) { + Wh_Log(L"Explorer restart skipped (already restarted once)"); + return false; } + DWORD written = 0; + WriteFile(h, "1", 1, &written, nullptr); + CloseHandle(h); + return true; +} - std::ofstream out(flag.c_str(), std::ios::trunc); - out << "1"; - return static_cast(out); +void ClearExplorerRestartFlag() { + const auto base = GetAppDataPrayerTrayPath(); + if (base.empty()) { + return; + } + DeleteFileW((base + L"\\explorer-restart.flag").c_str()); } void ScheduleExplorerRestart() { @@ -2337,13 +2337,17 @@ void ScheduleExplorerRestart() { void MaybeRestartExplorerForSlot() { ApplyEngineToBackends(); if (SlotUiReady()) { + // Slot worked — allow one restart again if the mod is later re-enabled + // and injection fails. Do not clear on unload: that would re-arm a loop + // when Explorer is killed for the restart itself. + ClearExplorerRestartFlag(); return; } if (!FindCurrentProcessTaskbarWnd()) { // Folder explorers have no tray — don't kill the shell for them. return; } - if (!ClaimExplorerRestart()) { + if (!ClaimExplorerRestartOnce()) { return; } ScheduleExplorerRestart(); From d71c943075cecfd311626d9d0cfcd5d275ef87eb Mon Sep 17 00:00:00 2001 From: omaralhami Date: Sun, 19 Jul 2026 05:48:35 +0300 Subject: [PATCH 09/10] Update PrayerTray to 3.1.1 --- mods/prayertray.wh.cpp | 2183 ++++++++++++++++++++++++++-------------- 1 file changed, 1450 insertions(+), 733 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index c975866217..aedf30d26c 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,13 +2,13 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 2.1.7 +// @version 3.1.1 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray // @include explorer.exe // @architecture x86-64 -// @compilerOptions -lole32 -loleaut32 -lruntimeobject -lshlwapi -lwinhttp -lwinmm -lversion -lcomctl32 -lgdi32 -ldwmapi +// @compilerOptions -lole32 -loleaut32 -lruntimeobject -lwindowsapp -lshlwapi -lshell32 -ladvapi32 -luser32 -lwinhttp -lwinmm -lversion -lcomctl32 -lgdi32 -ldwmapi // ==/WindhawkMod== // ==WindhawkModReadme== @@ -21,9 +21,9 @@ you work, without opening another app. Left-click opens today's times ## Location -Uses Windows Location when it is allowed, otherwise IP geolocation. -You can also set city or coordinates in the mod settings. -Privacy > Location > allow desktop apps if you want Windows Location. +Uses HTTPS IP geolocation with a cached offline fallback. IP location can be +affected by VPNs and ISP routing; manual coordinates are the reliable option +when an exact city is required. ## Source @@ -58,13 +58,19 @@ If you love this, you can support me on Patreon :) $description: Used when manual location is on - manualLatitude: "" $name: Latitude - $description: Optional decimals; more precise than city alone + $description: Decimal degrees; enter both latitude and longitude - manualLongitude: "" $name: Longitude - $description: Optional decimals; more precise than city alone + $description: Decimal degrees; enter both latitude and longitude - calculationMethod: 0 $name: Calculation method $description: Leave at 0 for your country's default. Advanced users can set an Aladhan method number. +- asrSchool: standard + $name: Asr calculation + $description: Standard is used by Shafi, Maliki and Hanbali schools. Choose Hanafi for the later Asr time. + $options: + - standard: Standard + - hanafi: Hanafi - taskbarContentMode: smart $name: Taskbar text $description: Countdown, prayer clock time, or auto @@ -99,29 +105,35 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"2.1.7" +#define WH_MOD_VERSION L"3.1.1" #endif #include #include #include -#include +#include #include +#include +#include #include -#include -#include +#include +#include #include +#include +#include +#include #include +#include #include #include #include #include #include #include -#include #include #include +#include #include #include @@ -131,7 +143,7 @@ If you love this, you can support me on Patreon :) #undef GetCurrentTime -#include +#include #include #include #include @@ -153,13 +165,14 @@ constexpr wchar_t kPdf = L'\u202C'; constexpr int kNotificationLeadMinutes = 1; constexpr int kCurrentPrayerHighlightMinutes = 2; constexpr int kCacheStaleHours = 6; +constexpr int kLocationRefreshHours = 24; constexpr double kClusterDistanceKm = 80.0; constexpr int kScheduleRefreshIntervalMs = 15 * 60 * 1000; -constexpr int kGeoAccessTimeoutMs = 8000; constexpr int kRunFromWindowTimeoutMs = 3000; constexpr wchar_t kNotificationSoundUrl[] = L"https://raw.githubusercontent.com/n0tmar/PrayerTray/main/windhawk/audio/allah-akbar.mp3"; -constexpr unsigned kNotificationSoundBytes = 85512; +constexpr size_t kNotificationSoundMinBytes = 4096; +constexpr size_t kNotificationSoundMaxBytes = 1024 * 1024; enum class PrayerName { Fajr, Dhuhr, Asr, Maghrib, Isha, Count }; @@ -177,6 +190,7 @@ struct ModSettings { std::wstring manualLatitude; std::wstring manualLongitude; int calculationMethod = 0; + bool hanafiAsr = false; ContentMode contentMode = ContentMode::Smart; bool use24Hour = false; std::wstring language = L"en"; @@ -235,6 +249,7 @@ struct IpCandidate { }; ModSettings g_settings; +std::mutex g_settingsMutex; std::mutex g_scheduleMutex; LocationInfo g_location; PrayerSchedule g_currentSchedule; @@ -242,7 +257,7 @@ PrayerSchedule g_nextSchedule; bool g_hasCurrentSchedule = false; bool g_hasNextSchedule = false; std::atomic g_unloading{false}; -std::atomic g_refreshRequested{true}; +std::atomic g_refreshRequested{false}; std::atomic g_refreshRunning{false}; std::atomic g_forceLocationRefresh{false}; std::atomic g_lastRefreshFailed{false}; @@ -251,11 +266,19 @@ std::atomic g_backend{TaskbarBackend::Win11Xaml}; std::atomic g_isWin11{false}; std::atomic g_uiTimerIntervalMs{500}; +HANDLE g_stopEvent = nullptr; +HANDLE g_refreshWakeEvent = nullptr; +HANDLE g_refreshThread = nullptr; +HANDLE g_uiReadyEvent = nullptr; +HANDLE g_uiThread = nullptr; +DWORD g_uiThreadId = 0; +HMODULE g_moduleInstance = nullptr; +std::atomic g_soundPreviewRequested{false}; + HWND g_messageHwnd = nullptr; UINT_PTR g_uiTimer = 0; UINT_PTR g_repositionTimer = 0; UINT_PTR g_fullscreenTimer = 0; -UINT_PTR g_scheduleTimer = 0; HWND g_win10OverlayHwnd = nullptr; HWND g_flyoutHwnd = nullptr; bool g_flyoutVisible = false; @@ -264,15 +287,18 @@ ULONGLONG g_flyoutSuppressDismissUntil = 0; NOTIFYICONDATAW g_trayIcon{}; bool g_trayIconAdded = false; HMENU g_contextMenu = nullptr; +bool g_messageClassRegistered = false; +bool g_flyoutClassRegistered = false; +bool g_overlayClassRegistered = false; std::unordered_set g_playedNotificationKeys; int g_notificationActiveDateKey = 0; -std::atomic g_taskbarViewDllLoaded; +std::atomic g_systemTrayModuleHooked{false}; std::atomic g_slotInjected; std::atomic g_applySlotAttempts; std::atomic g_injectRetryMs{100}; -std::atomic g_lastMeasureInjectAttemptMs{0}; +std::atomic g_nextInjectionFailureLogMs{0}; int g_lastUiTimerIntervalMs = -1; bool g_hasOverlayPlacement = false; int g_lastOverlayX = 0; @@ -300,9 +326,17 @@ std::wstring g_lastAppliedColor; constexpr int kCmdShowFlyout = 1; constexpr int kCmdShowMenu = 2; constexpr int kCmdRefreshLocation = 3; -constexpr UINT WM_PT_REFRESH = WM_APP + 1; -constexpr UINT WM_PT_UI_TICK = WM_APP + 2; -constexpr UINT WM_PT_HIDE_FLYOUT = WM_APP + 3; +constexpr UINT WM_PT_UI_TICK = WM_APP + 1; +constexpr UINT WM_PT_HIDE_FLYOUT = WM_APP + 2; +constexpr UINT WM_PT_SETTINGS_CHANGED = WM_APP + 3; +constexpr UINT WM_PT_AFTER_INIT = WM_APP + 4; +constexpr UINT WM_PT_PLAY_SOUND = WM_APP + 5; + +using WindowThreadAction = std::function; +bool RunFromWindowThread(HWND hWnd, WindowThreadAction action, + DWORD timeoutMs = kRunFromWindowTimeoutMs); +HWND FindCurrentProcessTaskbarWnd(); +constexpr UINT WM_PT_SHUTDOWN = WM_APP + 6; typedef LONG(WINAPI* RtlGetVersion_t)(PRTL_OSVERSIONINFOW); @@ -356,13 +390,15 @@ bool SameDate(const SYSTEMTIME& a, int y, int m, int d) { ULONGLONG SystemTimeToUnixSeconds(const SYSTEMTIME& st) { SYSTEMTIME utc{}; - TzSpecificLocalTimeToSystemTime(nullptr, &st, &utc); + if (!TzSpecificLocalTimeToSystemTime(nullptr, &st, &utc)) return 0; FILETIME ft{}; - SystemTimeToFileTime(&utc, &ft); + if (!SystemTimeToFileTime(&utc, &ft)) return 0; ULARGE_INTEGER uli{}; uli.LowPart = ft.dwLowDateTime; uli.HighPart = ft.dwHighDateTime; - return (uli.QuadPart - 116444736000000000ULL) / 10000000ULL; + constexpr ULONGLONG epoch = 116444736000000000ULL; + if (uli.QuadPart < epoch) return 0; + return (uli.QuadPart - epoch) / 10000000ULL; } ULONGLONG LocalNowUnixSeconds() { @@ -493,9 +529,15 @@ std::wstring UrlEncode(const std::wstring& value) { } bool ParseDouble(const std::wstring& text, double& out) { + const std::wstring clean = Trim(text); + if (clean.empty()) { + return false; + } wchar_t* end = nullptr; - out = wcstod(text.c_str(), &end); - return end && end != text.c_str(); + errno = 0; + out = wcstod(clean.c_str(), &end); + return errno != ERANGE && end && end != clean.c_str() && *end == L'\0' && + std::isfinite(out); } ContentMode ParseContentMode(const std::wstring& mode) { @@ -528,6 +570,7 @@ void LoadSettings() { s.manualLatitude = takeString(L"manualLatitude"); s.manualLongitude = takeString(L"manualLongitude"); s.calculationMethod = static_cast(Wh_GetIntSetting(L"calculationMethod")); + s.hanafiAsr = takeString(L"asrSchool") == L"hanafi"; s.contentMode = ParseContentMode(takeString(L"taskbarContentMode")); s.use24Hour = takeString(L"timeFormat") == L"24h"; s.language = takeString(L"language"); @@ -535,11 +578,18 @@ void LoadSettings() { s.language = L"en"; } s.oldTaskbarOnWin11 = Wh_GetIntSetting(L"oldTaskbarOnWin11") != 0; + std::lock_guard lock(g_settingsMutex); g_settings = std::move(s); } +ModSettings GetSettingsSnapshot() { + std::lock_guard lock(g_settingsMutex); + return g_settings; +} + bool IsRtlLanguage() { - return g_settings.language == L"ar" || g_settings.language == L"ur"; + const auto settings = GetSettingsSnapshot(); + return settings.language == L"ar" || settings.language == L"ur"; } bool IsLightTheme() { @@ -551,13 +601,123 @@ bool IsLightTheme() { } DWORD value = 0; DWORD size = sizeof(value); - RegQueryValueExW(key, L"AppsUseLightTheme", nullptr, nullptr, - reinterpret_cast(&value), &size); + LSTATUS status = RegQueryValueExW( + key, L"SystemUsesLightTheme", nullptr, nullptr, + reinterpret_cast(&value), &size); + if (status != ERROR_SUCCESS) { + size = sizeof(value); + RegQueryValueExW(key, L"AppsUseLightTheme", nullptr, nullptr, + reinterpret_cast(&value), &size); + } RegCloseKey(key); return value == 1; } +struct TaskbarPalette { + COLORREF background = RGB(32, 32, 32); + COLORREF foreground = RGB(255, 255, 255); + COLORREF secondary = RGB(180, 180, 180); + COLORREF highlight = RGB(50, 50, 50); + COLORREF border = RGB(96, 96, 96); +}; + +int ColorLuminance(COLORREF color) { + return (299 * GetRValue(color) + 587 * GetGValue(color) + + 114 * GetBValue(color)) / + 1000; +} + +COLORREF BlendColor(COLORREF from, COLORREF to, double amount) { + auto blend = [amount](BYTE a, BYTE b) { + return static_cast(std::clamp( + std::lround(a + (b - a) * amount), 0L, 255L)); + }; + return RGB(blend(GetRValue(from), GetRValue(to)), + blend(GetGValue(from), GetGValue(to)), + blend(GetBValue(from), GetBValue(to))); +} + +std::optional SampleTaskbarBackground() { + HWND taskbar = FindWindowW(L"Shell_TrayWnd", nullptr); + RECT rect{}; + if (!taskbar || !GetWindowRect(taskbar, &rect) || + rect.right <= rect.left || rect.bottom <= rect.top) { + return std::nullopt; + } + + HDC screen = GetDC(nullptr); + if (!screen) return std::nullopt; + + std::vector reds; + std::vector greens; + std::vector blues; + auto sample = [&](int x, int y) { + x = std::clamp(x, static_cast(rect.left) + 2, + static_cast(rect.right) - 3); + y = std::clamp(y, static_cast(rect.top) + 2, + static_cast(rect.bottom) - 3); + const COLORREF color = GetPixel(screen, x, y); + if (color != CLR_INVALID) { + reds.push_back(GetRValue(color)); + greens.push_back(GetGValue(color)); + blues.push_back(GetBValue(color)); + } + }; + + const int width = rect.right - rect.left; + const int height = rect.bottom - rect.top; + if (width >= height) { + for (int xPercent : {3, 12, 25, 40, 60, 75, 88, 97}) { + for (int yPercent : {25, 50, 75}) { + sample(rect.left + width * xPercent / 100, + rect.top + height * yPercent / 100); + } + } + } else { + for (int yPercent : {3, 12, 25, 40, 60, 75, 88, 97}) { + for (int xPercent : {25, 50, 75}) { + sample(rect.left + width * xPercent / 100, + rect.top + height * yPercent / 100); + } + } + } + ReleaseDC(nullptr, screen); + if (reds.empty()) return std::nullopt; + + auto median = [](std::vector& values) { + const auto middle = values.begin() + values.size() / 2; + std::nth_element(values.begin(), middle, values.end()); + return *middle; + }; + return RGB(median(reds), median(greens), median(blues)); +} + +TaskbarPalette GetTaskbarPalette() { + static std::mutex cacheMutex; + static TaskbarPalette cached; + static ULONGLONG sampledAt = 0; + std::lock_guard lock(cacheMutex); + const ULONGLONG now = GetTickCount64(); + if (sampledAt && now - sampledAt < 750) return cached; + + TaskbarPalette palette; + palette.background = SampleTaskbarBackground().value_or( + IsLightTheme() ? RGB(252, 252, 252) : RGB(32, 32, 32)); + const bool light = ColorLuminance(palette.background) >= 150; + palette.foreground = light ? RGB(26, 26, 26) : RGB(255, 255, 255); + palette.secondary = BlendColor(palette.background, palette.foreground, 0.65); + palette.highlight = BlendColor(palette.background, palette.foreground, + light ? 0.09 : 0.18); + palette.border = BlendColor(palette.background, palette.foreground, + light ? 0.22 : 0.30); + cached = palette; + sampledAt = now; + return cached; +} + std::wstring TaskbarTextColorHex() { + // Keep screen capture out of Explorer's startup and taskbar render loop. + // The flyout samples the taskbar only after the user explicitly opens it. return IsLightTheme() ? L"1A1A1A" : L"FFFFFF"; } @@ -653,7 +813,7 @@ const LocTable& GetLocTable() { {L"Countdown_Seconds", L"{0} d"}, {L"Countdown_Minutes", L"{0} m"}, {L"Countdown_Hours", L"{0} j"}, {L"Countdown_HoursMinutes", L"{0} j {1} m"}}}, }; - std::wstring lang = g_settings.language; + std::wstring lang = GetSettingsSnapshot().language; for (auto& ch : lang) { if (ch >= L'A' && ch <= L'Z') { ch = static_cast(ch - L'A' + L'a'); @@ -731,8 +891,9 @@ std::wstring StabilizeCompactText(const std::wstring& text) { } std::wstring FormatTime(const SYSTEMTIME& time) { + const auto settings = GetSettingsSnapshot(); std::wstring text; - if (g_settings.use24Hour) { + if (settings.use24Hour) { wchar_t buf[16]; swprintf(buf, 16, L"%02u%c%02u", time.wHour, kColonRatio, time.wMinute); text = buf; @@ -790,7 +951,26 @@ std::wstring LocationDisplayName(const LocationInfo& loc) { } -std::optional HttpGetUtf8(const std::wstring& url, bool useHttps = true) { +struct WinHttpHandle { + HINTERNET value = nullptr; + WinHttpHandle() = default; + explicit WinHttpHandle(HINTERNET value) : value(value) {} + ~WinHttpHandle() { + if (value) WinHttpCloseHandle(value); + } + WinHttpHandle(const WinHttpHandle&) = delete; + WinHttpHandle& operator=(const WinHttpHandle&) = delete; + operator HINTERNET() const { return value; } +}; + +bool StopRequested() { + return g_unloading.load() || + (g_stopEvent && WaitForSingleObject(g_stopEvent, 0) == WAIT_OBJECT_0); +} + +std::optional HttpGetUtf8(const std::wstring& url, + size_t maxBytes = 1024 * 1024) { + if (StopRequested()) return std::nullopt; URL_COMPONENTS uc{}; uc.dwStructSize = sizeof(uc); wchar_t host[256]{}; @@ -805,139 +985,147 @@ std::optional HttpGetUtf8(const std::wstring& url, bool useHttps = if (!WinHttpCrackUrl(url.c_str(), 0, 0, &uc)) { return std::nullopt; } - const bool https = useHttps || uc.nScheme == INTERNET_SCHEME_HTTPS; - HINTERNET session = - WinHttpOpen(L"PrayerTray/2.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, - WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0); + if (uc.nScheme != INTERNET_SCHEME_HTTPS) { + Wh_Log(L"Blocked non-HTTPS request"); + return std::nullopt; + } + WinHttpHandle session(WinHttpOpen( + L"PrayerTray/3.1.1 (+https://github.com/n0tmar/PrayerTray)", + WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, + WINHTTP_NO_PROXY_BYPASS, 0)); if (!session) { return std::nullopt; } - WinHttpSetTimeouts(session, 2000, 2000, 4000, 4000); - HINTERNET connect = WinHttpConnect(session, host, uc.nPort, 0); + WinHttpSetTimeouts(session, 1500, 1500, 3000, 3000); + WinHttpHandle connect(WinHttpConnect(session, host, uc.nPort, 0)); if (!connect) { - WinHttpCloseHandle(session); return std::nullopt; } std::wstring objectName = std::wstring(path) + extra; - DWORD flags = https ? WINHTTP_FLAG_SECURE : 0; - HINTERNET request = WinHttpOpenRequest( + WinHttpHandle request(WinHttpOpenRequest( connect, L"GET", objectName.c_str(), nullptr, WINHTTP_NO_REFERER, - WINHTTP_DEFAULT_ACCEPT_TYPES, flags); + WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE)); if (!request) { - WinHttpCloseHandle(connect); - WinHttpCloseHandle(session); return std::nullopt; } - if (!WinHttpSendRequest(request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, + const wchar_t headers[] = L"Accept: */*\r\n"; + if (!WinHttpSendRequest(request, headers, static_cast(-1L), WINHTTP_NO_REQUEST_DATA, 0, 0, 0) || !WinHttpReceiveResponse(request, nullptr)) { - WinHttpCloseHandle(request); - WinHttpCloseHandle(connect); - WinHttpCloseHandle(session); + Wh_Log(L"HTTPS request failed for %s (%u)", host, GetLastError()); + return std::nullopt; + } + DWORD status = 0; + DWORD statusSize = sizeof(status); + if (!WinHttpQueryHeaders(request, + WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + WINHTTP_HEADER_NAME_BY_INDEX, &status, &statusSize, + WINHTTP_NO_HEADER_INDEX) || + status < 200 || status >= 300) { + Wh_Log(L"HTTP %u for %s", status, host); return std::nullopt; } std::string body; DWORD available = 0; do { if (!WinHttpQueryDataAvailable(request, &available)) { - break; + return std::nullopt; } if (available == 0) { break; } + if (available > maxBytes || body.size() > maxBytes - available) { + Wh_Log(L"HTTP response too large from %s", host); + return std::nullopt; + } size_t offset = body.size(); body.resize(offset + available); DWORD read = 0; if (!WinHttpReadData(request, body.data() + offset, available, &read)) { body.resize(offset); - break; + return std::nullopt; } body.resize(offset + read); } while (available > 0); - WinHttpCloseHandle(request); - WinHttpCloseHandle(connect); - WinHttpCloseHandle(session); return body.empty() ? std::nullopt : std::optional{std::move(body)}; } -std::optional JsonFindValue(std::string_view json, - std::string_view key) { - std::string needle = std::string("\"") + std::string(key) + "\":"; - size_t pos = json.find(needle); - if (pos == std::string_view::npos) { - return std::nullopt; - } - pos += needle.size(); - while (pos < json.size() && (json[pos] == ' ' || json[pos] == '\t')) { - ++pos; - } - if (pos >= json.size()) { +std::optional ParseJsonObject( + std::string_view json) { + try { + return winrt::Windows::Data::Json::JsonObject::Parse(Utf8ToWide(json)); + } catch (...) { return std::nullopt; } - if (json[pos] == '"') { - ++pos; - size_t end = pos; - while (end < json.size() && json[end] != '"') { - if (json[end] == '\\' && end + 1 < json.size()) { - end += 2; - } else { - ++end; - } - } - return json.substr(pos, end - pos); - } - size_t end = pos; - while (end < json.size() && json[end] != ',' && json[end] != '}' && - json[end] != ']') { - ++end; - } - return json.substr(pos, end - pos); } std::optional JsonGetDouble(std::string_view json, std::string_view key) { - if (auto val = JsonFindValue(json, key)) { - try { - return std::stod(std::string(*val)); - } catch (...) { + auto object = ParseJsonObject(json); + if (!object) return std::nullopt; + try { + const auto name = Utf8ToWide(key); + auto value = object->GetNamedValue(name); + if (value.ValueType() == winrt::Windows::Data::Json::JsonValueType::Number) + return value.GetNumber(); + if (value.ValueType() == winrt::Windows::Data::Json::JsonValueType::String) { + double parsed = 0; + if (ParseDouble(value.GetString().c_str(), parsed)) return parsed; } + } catch (...) { } return std::nullopt; } std::wstring JsonGetStringW(std::string_view json, std::string_view key) { - if (auto val = JsonFindValue(json, key)) { - return Utf8ToWide(*val); + auto object = ParseJsonObject(json); + if (!object) return L""; + try { + auto value = object->GetNamedValue(Utf8ToWide(key)); + if (value.ValueType() == winrt::Windows::Data::Json::JsonValueType::String) + return value.GetString().c_str(); + } catch (...) { } return L""; } -std::optional JsonFindObject(std::string_view json, - std::string_view key) { - std::string needle = std::string("\"") + std::string(key) + "\":"; - size_t pos = json.find(needle); - if (pos == std::string_view::npos) { - return std::nullopt; - } - pos += needle.size(); - while (pos < json.size() && json[pos] != '{') { - ++pos; +std::optional JsonGetBool(std::string_view json, std::string_view key) { + auto object = ParseJsonObject(json); + if (!object) return std::nullopt; + try { + auto value = object->GetNamedValue(Utf8ToWide(key)); + if (value.ValueType() == winrt::Windows::Data::Json::JsonValueType::Boolean) + return value.GetBoolean(); + } catch (...) { } - if (pos >= json.size()) { + return std::nullopt; +} + +std::optional JsonFindObject(std::string_view json, + std::string_view key) { + auto object = ParseJsonObject(json); + if (!object) return std::nullopt; + try { + auto child = object->GetNamedObject(Utf8ToWide(key)); + return WideToUtf8(child.Stringify().c_str()); + } catch (...) { return std::nullopt; } - int depth = 0; - size_t start = pos; - for (; pos < json.size(); ++pos) { - if (json[pos] == '{') { - ++depth; - } else if (json[pos] == '}') { - --depth; - if (depth == 0) { - return json.substr(start, pos - start + 1); - } +} + +std::wstring JsonGetFirstArrayString(std::string_view json, + std::string_view key) { + auto object = ParseJsonObject(json); + if (!object) return L""; + try { + auto array = object->GetNamedArray(Utf8ToWide(key)); + if (array.Size() && + array.GetAt(0).ValueType() == + winrt::Windows::Data::Json::JsonValueType::String) { + return array.GetStringAt(0).c_str(); } + } catch (...) { } - return std::nullopt; + return L""; } int GetDefaultMethodForCountry(const std::wstring& country) { @@ -971,6 +1159,8 @@ std::wstring GetCountryCode(const std::wstring& country) { if (n == L"KUWAIT") return L"KW"; if (n == L"QATAR") return L"QA"; if (n == L"CANADA") return L"CA"; + if (n == L"BANGLADESH") return L"BD"; + if (n == L"IRAN") return L"IR"; return L""; } @@ -986,12 +1176,15 @@ std::wstring GetDefaultTimezoneForCountry(const std::wstring& country) { if (n == L"MALAYSIA") return L"Asia/Kuala_Lumpur"; if (n == L"PAKISTAN") return L"Asia/Karachi"; if (n == L"INDIA") return L"Asia/Kolkata"; + if (n == L"BANGLADESH") return L"Asia/Dhaka"; + if (n == L"IRAN") return L"Asia/Tehran"; return L""; } -int ResolveCalculationMethod(const LocationInfo& loc) { - if (g_settings.calculationMethod > 0) { - return g_settings.calculationMethod; +int ResolveCalculationMethod(const LocationInfo& loc, + const ModSettings& settings) { + if (settings.calculationMethod > 0) { + return settings.calculationMethod; } return GetDefaultMethodForCountry(loc.country); } @@ -1006,23 +1199,21 @@ double DistanceKm(const IpCandidate& a, const IpCandidate& b) { double sinLat = sin(dLat / 2); double sinLon = sin(dLon / 2); double h = sinLat * sinLat + cos(lat1) * cos(lat2) * sinLon * sinLon; + h = (std::clamp)(h, 0.0, 1.0); return earthRadiusKm * 2 * atan2(sqrt(h), sqrt(1 - h)); } -std::optional TryFetchIpApi() { - auto body = HttpGetUtf8(L"http://ip-api.com/json/?fields=status,message,lat,lon,city,regionName,country,timezone", false); - if (!body) return std::nullopt; - if (JsonGetStringW(*body, "status") != L"success") return std::nullopt; - IpCandidate c; - c.provider = L"ip-api"; - c.weight = 2; - c.latitude = JsonGetDouble(*body, "lat").value_or(0); - c.longitude = JsonGetDouble(*body, "lon").value_or(0); - c.city = JsonGetStringW(*body, "city"); - c.region = JsonGetStringW(*body, "regionName"); - c.country = JsonGetStringW(*body, "country"); - c.timezone = JsonGetStringW(*body, "timezone"); - return c; +bool IsValidCoordinate(double latitude, double longitude) { + return std::isfinite(latitude) && std::isfinite(longitude) && + latitude >= -90.0 && latitude <= 90.0 && longitude >= -180.0 && + longitude <= 180.0 && !(latitude == 0.0 && longitude == 0.0); +} + +std::optional ValidateCandidate(IpCandidate candidate) { + if (!IsValidCoordinate(candidate.latitude, candidate.longitude)) { + return std::nullopt; + } + return candidate; } std::wstring ReadCountryNameFromCode(const std::wstring& code) { @@ -1037,6 +1228,11 @@ std::wstring ReadCountryNameFromCode(const std::wstring& code) { if (c == L"TR") return L"Turkey"; if (c == L"ID") return L"Indonesia"; if (c == L"MY") return L"Malaysia"; + if (c == L"KW") return L"Kuwait"; + if (c == L"QA") return L"Qatar"; + if (c == L"CA") return L"Canada"; + if (c == L"BD") return L"Bangladesh"; + if (c == L"IR") return L"Iran"; return code; } @@ -1050,20 +1246,21 @@ std::optional TryFetchIpInfo() { IpCandidate c; c.provider = L"ipinfo"; c.weight = 3; - c.latitude = wcstod(loc.c_str(), nullptr); - c.longitude = wcstod(loc.substr(comma + 1).c_str(), nullptr); + if (!ParseDouble(loc.substr(0, comma), c.latitude) || + !ParseDouble(loc.substr(comma + 1), c.longitude)) { + return std::nullopt; + } c.city = JsonGetStringW(*body, "city"); c.region = JsonGetStringW(*body, "region"); c.country = ReadCountryNameFromCode(JsonGetStringW(*body, "country")); c.timezone = JsonGetStringW(*body, "timezone"); - return c; + return ValidateCandidate(std::move(c)); } std::optional TryFetchIpWho() { auto body = HttpGetUtf8(L"https://ipwho.is/"); if (!body) return std::nullopt; - auto success = JsonFindValue(*body, "success"); - if (!success || *success != "true") return std::nullopt; + if (!JsonGetBool(*body, "success").value_or(false)) return std::nullopt; IpCandidate c; c.provider = L"ipwho"; c.weight = 1; @@ -1075,7 +1272,7 @@ std::optional TryFetchIpWho() { if (auto tzObj = JsonFindObject(*body, "timezone")) { c.timezone = JsonGetStringW(*tzObj, "id"); } - return c; + return ValidateCandidate(std::move(c)); } IpCandidate SelectBestCandidate(std::vector& candidates) { @@ -1150,8 +1347,8 @@ IpCandidate SelectBestCandidate(std::vector& candidates) { result.weight = weight; result.latitude = lat; result.longitude = lon; - // Prefer reverse-geocode city over IP label. - result.city.clear(); + // FillFromCoords prefers reverse-geocode names and retains this as fallback. + result.city = bestNamed->city; result.region = bestNamed->region; result.country = bestNamed->country; result.timezone = bestNamed->timezone; @@ -1170,24 +1367,8 @@ std::optional TryFetchFreeIpApi() { c.city = JsonGetStringW(*body, "cityName"); c.region = JsonGetStringW(*body, "regionName"); c.country = JsonGetStringW(*body, "countryName"); - c.timezone = JsonGetStringW(*body, "timeZones"); - if (c.timezone.empty()) { - if (auto zones = JsonFindObject(*body, "timeZones")) { - (void)zones; - } - // freeipapi may return timeZones as an array; first quoted value is enough. - auto pos = body->find("\"timeZones\""); - if (pos != std::string::npos) { - auto q1 = body->find('"', body->find('[', pos)); - if (q1 != std::string::npos) { - auto q2 = body->find('"', q1 + 1); - if (q2 != std::string::npos) { - c.timezone = Utf8ToWide(body->substr(q1 + 1, q2 - q1 - 1)); - } - } - } - } - return c; + c.timezone = JsonGetFirstArrayString(*body, "timeZones"); + return ValidateCandidate(std::move(c)); } std::optional TryFetchGeoJs() { @@ -1210,7 +1391,7 @@ std::optional TryFetchGeoJs() { c.city = JsonGetStringW(*body, "city"); c.region = JsonGetStringW(*body, "region"); c.country = JsonGetStringW(*body, "country"); - return c; + return ValidateCandidate(std::move(c)); } struct ReverseGeocodeResult { @@ -1224,7 +1405,7 @@ std::wstring FixCityName(std::wstring city) { auto upper = ToUpper(city); if (upper == L"MAKKAH" || upper == L"MAKKAH AL MUKARRAMAH" || upper == L"MECCA" || upper == L"MEKKAH") { - return L"Mecca"; + return L"Makkah"; } if (upper == L"AL TAIF" || upper == L"AT TAIF" || upper == L"TA'IF") { return L"Taif"; @@ -1248,10 +1429,6 @@ std::optional TryReverseGeocode(double latitude, double lo result.region = JsonGetStringW(*body, "principalSubdivision"); result.country = JsonGetStringW(*body, "countryName"); result.timezone = JsonGetStringW(*body, "ianaTimeId"); - if (result.timezone.empty()) { - result.timezone = JsonGetStringW(*body, "localityInfo"); // ignored if wrong shape - result.timezone.clear(); - } if (result.city.empty() && result.country.empty()) { return std::nullopt; } @@ -1269,15 +1446,22 @@ std::wstring FirstNonEmpty(std::initializer_list values) { } LocationInfo ResolveManualLocation() { + const auto settings = GetSettingsSnapshot(); LocationInfo loc; loc.source = L"manual"; loc.resolvedAtUtcMs = GetUtcNowMs(); - loc.city = FixCityName(Trim(g_settings.manualCity)); - loc.country = Trim(g_settings.manualCountry); + loc.city = FixCityName(Trim(settings.manualCity)); + loc.country = Trim(settings.manualCountry); loc.timezone = GetDefaultTimezoneForCountry(loc.country); double lat = 0, lon = 0; - if (ParseDouble(g_settings.manualLatitude, lat) && - ParseDouble(g_settings.manualLongitude, lon)) { + const bool hasLatitude = !Trim(settings.manualLatitude).empty(); + const bool hasLongitude = !Trim(settings.manualLongitude).empty(); + if (hasLatitude || hasLongitude) { + if (!ParseDouble(settings.manualLatitude, lat) || + !ParseDouble(settings.manualLongitude, lon) || lat < -90.0 || + lat > 90.0 || lon < -180.0 || lon > 180.0) { + throw std::runtime_error("manual coordinates are invalid"); + } loc.latitude = lat; loc.longitude = lon; return loc; @@ -1286,21 +1470,31 @@ LocationInfo ResolveManualLocation() { loc.source = L"manual-city"; return loc; } - loc.country = L"Unknown"; - return loc; + throw std::runtime_error("manual city and country are required"); } std::wstring JsonEscape(const std::wstring& value) { std::wstring out; out.reserve(value.size()); for (wchar_t ch : value) { - if (ch == L'\\' || ch == L'"') { - out.push_back(L'\\'); - out.push_back(ch); - } else if (ch == L'\n') { - out += L"\\n"; - } else { - out.push_back(ch); + switch (ch) { + case L'\\': out += L"\\\\"; break; + case L'"': out += L"\\\""; break; + case L'\b': out += L"\\b"; break; + case L'\f': out += L"\\f"; break; + case L'\n': out += L"\\n"; break; + case L'\r': out += L"\\r"; break; + case L'\t': out += L"\\t"; break; + default: + if (ch < 0x20) { + wchar_t escaped[7]; + swprintf(escaped, ARRAYSIZE(escaped), L"\\u%04X", + static_cast(ch)); + out += escaped; + } else { + out.push_back(ch); + } + break; } } return out; @@ -1315,15 +1509,63 @@ std::wstring GetLastLocationPath() { return base + L"\\last-location.json"; } +bool WriteTextFileAtomically(const std::wstring& path, const std::string& content) { + if (path.empty()) return false; + const std::wstring temp = path + L".tmp." + std::to_wstring(GetCurrentProcessId()) + + L"." + std::to_wstring(GetCurrentThreadId()); + HANDLE file = CreateFileW(temp.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, nullptr); + if (file == INVALID_HANDLE_VALUE) return false; + DWORD written = 0; + const bool wrote = content.size() <= MAXDWORD && + WriteFile(file, content.data(), + static_cast(content.size()), &written, + nullptr) && + written == content.size() && FlushFileBuffers(file); + CloseHandle(file); + if (!wrote || !MoveFileExW(temp.c_str(), path.c_str(), + MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) { + DeleteFileW(temp.c_str()); + return false; + } + return true; +} + +std::optional ReadTextFile(const std::wstring& path, + size_t maxBytes = 1024 * 1024) { + HANDLE file = CreateFileW(path.c_str(), GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE | + FILE_SHARE_DELETE, + nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, + nullptr); + if (file == INVALID_HANDLE_VALUE) return std::nullopt; + LARGE_INTEGER size{}; + if (!GetFileSizeEx(file, &size) || size.QuadPart <= 0 || + static_cast(size.QuadPart) > maxBytes || + size.QuadPart > MAXDWORD) { + CloseHandle(file); + return std::nullopt; + } + std::string data(static_cast(size.QuadPart), '\0'); + DWORD bytesRead = 0; + const bool read = ReadFile(file, data.data(), + static_cast(data.size()), &bytesRead, + nullptr) && + bytesRead == data.size(); + CloseHandle(file); + if (!read) { + return std::nullopt; + } + return data; +} + void SaveLastLocation(const LocationInfo& loc) { const auto path = GetLastLocationPath(); if (path.empty() || (loc.latitude == 0 && loc.longitude == 0 && loc.city.empty())) { return; } - std::ofstream out(path.c_str(), std::ios::binary | std::ios::trunc); - if (!out) { - return; - } + std::ostringstream out; + out << std::setprecision(15); out << "{\n"; out << " \"Latitude\": " << loc.latitude << ",\n"; out << " \"Longitude\": " << loc.longitude << ",\n"; @@ -1334,6 +1576,9 @@ void SaveLastLocation(const LocationInfo& loc) { out << " \"Source\": \"" << WideToUtf8(JsonEscape(loc.source)) << "\",\n"; out << " \"ResolvedAtUtcMs\": " << loc.resolvedAtUtcMs << "\n"; out << "}\n"; + if (!WriteTextFileAtomically(path, out.str())) { + Wh_Log(L"Failed to save location cache"); + } } std::optional LoadLastLocation() { @@ -1341,14 +1586,9 @@ std::optional LoadLastLocation() { if (path.empty()) { return std::nullopt; } - std::ifstream in(path.c_str(), std::ios::binary); - if (!in) { - return std::nullopt; - } - std::string json((std::istreambuf_iterator(in)), std::istreambuf_iterator()); - if (json.empty()) { - return std::nullopt; - } + auto contents = ReadTextFile(path, 64 * 1024); + if (!contents) return std::nullopt; + const std::string& json = *contents; LocationInfo loc; loc.latitude = JsonGetDouble(json, "Latitude").value_or(0); loc.longitude = JsonGetDouble(json, "Longitude").value_or(0); @@ -1356,8 +1596,10 @@ std::optional LoadLastLocation() { loc.region = JsonGetStringW(json, "Region"); loc.country = JsonGetStringW(json, "Country"); loc.timezone = JsonGetStringW(json, "Timezone"); - loc.source = L"last-known"; - loc.resolvedAtUtcMs = GetUtcNowMs(); + loc.source = JsonGetStringW(json, "Source"); + if (loc.source.empty()) loc.source = L"last-known"; + loc.resolvedAtUtcMs = static_cast( + JsonGetDouble(json, "ResolvedAtUtcMs").value_or(0)); if (loc.latitude == 0 && loc.longitude == 0 && loc.city.empty()) { return std::nullopt; } @@ -1395,102 +1637,9 @@ LocationInfo FillFromCoords(LocationInfo loc, return loc; } -std::optional TryWindowsLocation() { - try { - using namespace winrt::Windows::Devices::Geolocation; - using namespace winrt::Windows::Foundation; - using namespace std::chrono_literals; - - try { - winrt::init_apartment(winrt::apartment_type::multi_threaded); - } catch (winrt::hresult_error const&) { - } - - // RequestAccessAsync has no built-in timeout and can block the refresh - // pipeline forever if the consent prompt never resolves. - auto accessPromise = - std::make_shared>(); - auto accessFuture = accessPromise->get_future(); - std::thread([accessPromise]() { - try { - try { - winrt::init_apartment(winrt::apartment_type::multi_threaded); - } catch (...) { - } - accessPromise->set_value(Geolocator::RequestAccessAsync().get()); - } catch (...) { - try { - accessPromise->set_exception(std::current_exception()); - } catch (...) { - } - } - }).detach(); - - std::optional access; - if (accessFuture.wait_for(std::chrono::milliseconds(kGeoAccessTimeoutMs)) != - std::future_status::ready) { - Wh_Log(L"Windows Location access timed out"); - return std::nullopt; - } - try { - access = accessFuture.get(); - } catch (...) { - Wh_Log(L"Windows Location access failed"); - return std::nullopt; - } - if (!access || *access != GeolocationAccessStatus::Allowed) { - Wh_Log(L"Windows Location denied (%d)", - access ? static_cast(*access) : -1); - return std::nullopt; - } - - Geolocator locator; - const auto status = locator.LocationStatus(); - if (status == PositionStatus::Disabled || - status == PositionStatus::NotAvailable) { - Wh_Log(L"Windows Location off (%d)", - static_cast(status)); - return std::nullopt; - } - - locator.DesiredAccuracy(PositionAccuracy::Default); - try { - locator.DesiredAccuracyInMeters(1000); - } catch (...) { - } - - const auto position = - locator.GetGeopositionAsync(TimeSpan{30s}, TimeSpan{3s}).get(); - if (!position) { - Wh_Log(L"Windows Location: no fix"); - return std::nullopt; - } - - const auto coord = position.Coordinate().Point().Position(); - if (coord.Latitude == 0 && coord.Longitude == 0) { - Wh_Log(L"Windows Location: empty coords"); - return std::nullopt; - } - - LocationInfo loc = - FillFromCoords({}, coord.Latitude, coord.Longitude, L"windows"); - Wh_Log(L"Location (windows): %s, %s (%.5f, %.5f)", - loc.city.c_str(), loc.country.c_str(), loc.latitude, loc.longitude); - return loc; - } catch (winrt::hresult_error const& ex) { - Wh_Log(L"Windows Location failed: 0x%08X %s", - static_cast(ex.code()), ex.message().c_str()); - return std::nullopt; - } catch (...) { - Wh_Log(L"Windows Location failed"); - return std::nullopt; - } -} - LocationInfo TryIpLocation() { Wh_Log(L"Trying IP location"); std::vector>> jobs; - jobs.push_back(std::async(std::launch::async, TryFetchIpApi)); jobs.push_back(std::async(std::launch::async, TryFetchIpInfo)); jobs.push_back(std::async(std::launch::async, TryFetchIpWho)); jobs.push_back(std::async(std::launch::async, TryFetchFreeIpApi)); @@ -1512,14 +1661,14 @@ LocationInfo TryIpLocation() { LocationInfo loc = FillFromCoords( {}, winner.latitude, winner.longitude, L"ip", winner.city, winner.region, winner.country, winner.timezone); - Wh_Log(L"Location (ip): %s, %s (%.4f, %.4f) [%s]", - loc.city.c_str(), loc.country.c_str(), loc.latitude, loc.longitude, - winner.provider.c_str()); + Wh_Log(L"Location (ip): %s, %s [%s]", loc.city.c_str(), + loc.country.c_str(), winner.provider.c_str()); return loc; } LocationInfo ResolveLocation() { - if (g_settings.useManualLocation) { + const auto settings = GetSettingsSnapshot(); + if (settings.useManualLocation) { auto loc = ResolveManualLocation(); SaveLastLocation(loc); return loc; @@ -1527,10 +1676,8 @@ LocationInfo ResolveLocation() { // Prefer a known location immediately; refresh can replace it later. auto cachedLoc = LoadLastLocation(); - - if (auto loc = TryWindowsLocation()) { - SaveLastLocation(*loc); - return *loc; + if (cachedLoc && cachedLoc->source.starts_with(L"manual")) { + cachedLoc.reset(); } try { @@ -1560,9 +1707,30 @@ bool ParseTimeOnly(const std::wstring& text, SYSTEMTIME& outDate, SYSTEMTIME& ou } auto colon = clean.find(L':'); if (colon == std::wstring::npos) return false; + const auto secondColon = clean.find(L':', colon + 1); + const std::wstring minuteText = + secondColon == std::wstring::npos + ? clean.substr(colon + 1) + : clean.substr(colon + 1, secondColon - colon - 1); + double hourValue = 0; + double minuteValue = 0; + if (!ParseDouble(clean.substr(0, colon), hourValue) || + !ParseDouble(minuteText, minuteValue) || + std::floor(hourValue) != hourValue || + std::floor(minuteValue) != minuteValue || hourValue < 0 || + hourValue > 23 || minuteValue < 0 || minuteValue > 59) { + return false; + } + if (secondColon != std::wstring::npos) { + double seconds = 0; + if (!ParseDouble(clean.substr(secondColon + 1), seconds) || + std::floor(seconds) != seconds || seconds < 0 || seconds > 59) { + return false; + } + } outTime = outDate; - outTime.wHour = static_cast(wcstoul(clean.substr(0, colon).c_str(), nullptr, 10)); - outTime.wMinute = static_cast(wcstoul(clean.substr(colon + 1).c_str(), nullptr, 10)); + outTime.wHour = static_cast(hourValue); + outTime.wMinute = static_cast(minuteValue); outTime.wSecond = 0; outTime.wMilliseconds = 0; return true; @@ -1588,19 +1756,34 @@ PrayerSchedule BuildScheduleFromTimingsJson(std::string_view timingsJson, for (int i = 0; i < static_cast(PrayerName::Count); ++i) { auto name = static_cast(i); std::string key = WideToUtf8(PrayerApiKey(name)); - auto val = JsonFindValue(timingsJson, key); - if (!val) continue; + auto value = JsonGetStringW(timingsJson, key); + if (value.empty()) continue; PrayerEntry entry; entry.name = name; - if (ParseTimeOnly(Utf8ToWide(*val), date, entry.time)) { + if (ParseTimeOnly(value, date, entry.time)) { schedule.prayers.push_back(entry); } } return schedule; } +bool IsCompleteSchedule(const PrayerSchedule& schedule) { + if (schedule.prayers.size() != static_cast(PrayerName::Count)) { + return false; + } + bool seen[static_cast(PrayerName::Count)]{}; + for (const auto& prayer : schedule.prayers) { + const auto index = static_cast(prayer.name); + if (index >= static_cast(PrayerName::Count) || seen[index]) { + return false; + } + seen[index] = true; + } + return true; +} + std::wstring BuildCachePath(int year, int month, int day, const LocationInfo& loc, - int method) { + int method, int school) { std::wstring key; if (loc.latitude != 0 || loc.longitude != 0) { wchar_t buf[64]; @@ -1610,15 +1793,15 @@ std::wstring BuildCachePath(int year, int month, int day, const LocationInfo& lo key = loc.city + L"_" + loc.country; } key = SanitizeCachePart(key); - std::wstring tz = loc.timezone.empty() ? L"notz" : SanitizeCachePart(loc.timezone); wchar_t path[512]; - swprintf(path, 512, L"%04d-%02d-%02d_%s_m%d_%s.json", year, month, day, - key.c_str(), method, tz.c_str()); - return GetCacheFolder() + L"\\" + path; + swprintf(path, 512, L"%04d-%02d-%02d_%s_m%d_s%d.json", year, month, + day, key.c_str(), method, school); + const auto folder = GetCacheFolder(); + return folder.empty() ? L"" : folder + L"\\" + path; } std::wstring BuildIslamicAppUrl(int year, int month, int day, const LocationInfo& loc, - int method) { + int method, int school) { SYSTEMTIME now = GetLocalNow(); std::wstring dateSegment; if (year == now.wYear && month == now.wMonth && day == now.wDay) { @@ -1632,10 +1815,11 @@ std::wstring BuildIslamicAppUrl(int year, int month, int day, const LocationInfo if (loc.source == L"manual-city") { auto cc = GetCountryCode(loc.country); url += L"city=" + UrlEncode(loc.city) + L"&country=" + cc + L"&method=" + - std::to_wstring(method); + std::to_wstring(method) + L"&school=" + std::to_wstring(school); } else { url += L"latitude=" + std::to_wstring(loc.latitude) + L"&longitude=" + - std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method); + std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method) + + L"&school=" + std::to_wstring(school); if (!loc.timezone.empty()) { url += L"&timezone=" + UrlEncode(loc.timezone); } @@ -1644,18 +1828,20 @@ std::wstring BuildIslamicAppUrl(int year, int month, int day, const LocationInfo } std::wstring BuildAladhanUrl(int year, int month, int day, const LocationInfo& loc, - int method) { + int method, int school) { wchar_t dateSeg[16]; swprintf(dateSeg, 16, L"%02d-%02d-%04d", day, month, year); std::wstring url; if (loc.source == L"manual-city") { url = L"https://api.aladhan.com/v1/timingsByCity/" + std::wstring(dateSeg) + L"?city=" + UrlEncode(loc.city) + L"&country=" + UrlEncode(loc.country) + - L"&method=" + std::to_wstring(method); + L"&method=" + std::to_wstring(method) + L"&school=" + + std::to_wstring(school); } else { url = L"https://api.aladhan.com/v1/timings/" + std::wstring(dateSeg) + L"?latitude=" + std::to_wstring(loc.latitude) + L"&longitude=" + - std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method); + std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method) + + L"&school=" + std::to_wstring(school); if (!loc.timezone.empty()) { url += L"&timezonestring=" + UrlEncode(loc.timezone); } @@ -1663,8 +1849,9 @@ std::wstring BuildAladhanUrl(int year, int month, int day, const LocationInfo& l return url; } -PrayerSchedule FetchScheduleFromApi(int year, int month, int day, LocationInfo loc) { - int method = ResolveCalculationMethod(loc); +PrayerSchedule FetchScheduleFromApi(int year, int month, int day, + LocationInfo loc, int method, + int school) { auto parseResponse = [&](const std::string& body) -> PrayerSchedule { auto data = JsonFindObject(body, "data"); if (!data) throw std::runtime_error("no data"); @@ -1675,15 +1862,21 @@ PrayerSchedule FetchScheduleFromApi(int year, int month, int day, LocationInfo l auto tzVal = JsonGetStringW(*meta, "timezone"); if (!tzVal.empty()) tz = tzVal; } - return BuildScheduleFromTimingsJson(*timings, year, month, day, loc, tz); + auto schedule = + BuildScheduleFromTimingsJson(*timings, year, month, day, loc, tz); + if (!IsCompleteSchedule(schedule)) { + throw std::runtime_error("incomplete prayer timings"); + } + return schedule; }; try { - auto url = BuildIslamicAppUrl(year, month, day, loc, method); + auto url = BuildIslamicAppUrl(year, month, day, loc, method, school); auto body = HttpGetUtf8(url); if (!body) throw std::runtime_error("islamic.app failed"); return parseResponse(*body); } catch (...) { - auto url = BuildAladhanUrl(year, month, day, loc, method); + Wh_Log(L"Primary prayer API failed; trying Aladhan"); + auto url = BuildAladhanUrl(year, month, day, loc, method, school); auto body = HttpGetUtf8(url); if (!body) throw std::runtime_error("aladhan failed"); return parseResponse(*body); @@ -1706,15 +1899,19 @@ bool IsCacheStale(const PrayerSchedule& schedule, int y, int m, int d, } std::optional LoadCache(int year, int month, int day, - const LocationInfo& loc, int method) { - auto path = BuildCachePath(year, month, day, loc, method); - std::ifstream in(path.c_str(), std::ios::binary); - if (!in) return std::nullopt; - std::string json((std::istreambuf_iterator(in)), std::istreambuf_iterator()); - if (json.empty()) return std::nullopt; + const LocationInfo& loc, int method, + int school) { + auto path = BuildCachePath(year, month, day, loc, method, school); + auto contents = ReadTextFile(path, 256 * 1024); + if (!contents) return std::nullopt; + const std::string& json = *contents; PrayerSchedule schedule; auto dateStr = JsonGetStringW(json, "Date"); if (!dateStr.empty()) { + if (dateStr.size() < 10 || dateStr[4] != L'-' || + dateStr[7] != L'-') { + return std::nullopt; + } schedule.year = _wtoi(dateStr.substr(0, 4).c_str()); schedule.month = _wtoi(dateStr.substr(5, 2).c_str()); schedule.day = _wtoi(dateStr.substr(8, 2).c_str()); @@ -1724,7 +1921,12 @@ std::optional LoadCache(int year, int month, int day, schedule.day = day; } schedule.location = loc; - schedule.fetchedAtUtcMs = GetUtcNowMs(); + schedule.fetchedAtUtcMs = static_cast( + JsonGetDouble(json, "FetchedAtUtcMs").value_or(0)); + if (!schedule.fetchedAtUtcMs) { + // Old cache format: force a refresh instead of pretending it is new. + schedule.fetchedAtUtcMs = 1; + } if (auto locObj = JsonFindObject(json, "Location")) { schedule.location.city = JsonGetStringW(*locObj, "City"); schedule.location.country = JsonGetStringW(*locObj, "Country"); @@ -1732,26 +1934,29 @@ std::optional LoadCache(int year, int month, int day, schedule.location.latitude = JsonGetDouble(*locObj, "Latitude").value_or(loc.latitude); schedule.location.longitude = JsonGetDouble(*locObj, "Longitude").value_or(loc.longitude); } - if (auto prayersArr = json.find("\"Prayers\""); prayersArr != std::string::npos) { - SYSTEMTIME date{}; - date.wYear = static_cast(schedule.year); - date.wMonth = static_cast(schedule.month); - date.wDay = static_cast(schedule.day); - for (int i = 0; i < static_cast(PrayerName::Count); ++i) { - auto name = static_cast(i); - std::string key = "\"Name\":" + std::to_string(static_cast(name)); - (void)key; - } - } auto timings = JsonFindObject(json, "timings"); if (timings) { - return BuildScheduleFromTimingsJson(*timings, year, month, day, loc, loc.timezone); + auto parsed = BuildScheduleFromTimingsJson(*timings, year, month, day, + schedule.location, + schedule.location.timezone); + if (!IsCompleteSchedule(parsed)) { + return std::nullopt; + } + parsed.fetchedAtUtcMs = schedule.fetchedAtUtcMs; + return parsed; } for (int i = 0; i < static_cast(PrayerName::Count); ++i) { auto name = static_cast(i); std::string search = std::string("\"") + WideToUtf8(PrayerApiKey(name)) + "\""; if (json.find(search) != std::string::npos) { - return BuildScheduleFromTimingsJson(json, year, month, day, loc, loc.timezone); + auto parsed = BuildScheduleFromTimingsJson( + json, year, month, day, schedule.location, + schedule.location.timezone); + if (!IsCompleteSchedule(parsed)) { + return std::nullopt; + } + parsed.fetchedAtUtcMs = schedule.fetchedAtUtcMs; + return parsed; } } SYSTEMTIME date{}; @@ -1763,6 +1968,9 @@ std::optional LoadCache(int year, int month, int day, pos += 7; while (pos < json.size() && (json[pos] == ' ' || json[pos] == '"')) ++pos; int nameIdx = atoi(json.c_str() + pos); + if (nameIdx < 0 || nameIdx >= static_cast(PrayerName::Count)) { + return std::nullopt; + } pos = json.find("\"Time\":", pos); if (pos == std::string::npos) break; pos += 7; @@ -1774,9 +1982,9 @@ std::optional LoadCache(int year, int month, int day, std::wstring timeText = Utf8ToWide(json.substr(pos, end - pos)); if (timeText.size() >= 16) { SYSTEMTIME st = date; - st.wHour = static_cast(_wtoi(timeText.substr(11, 2).c_str())); - st.wMinute = static_cast(_wtoi(timeText.substr(14, 2).c_str())); - st.wSecond = 0; + if (!ParseTimeOnly(timeText.substr(11), date, st)) { + return std::nullopt; + } PrayerEntry entry; entry.name = static_cast(nameIdx); entry.time = st; @@ -1784,26 +1992,30 @@ std::optional LoadCache(int year, int month, int day, } pos = end; } - if (schedule.prayers.empty()) return std::nullopt; + if (!IsCompleteSchedule(schedule)) { + return std::nullopt; + } return schedule; } -void SaveCache(const PrayerSchedule& schedule, int method) { +void SaveCache(const PrayerSchedule& schedule, int method, int school, + const LocationInfo& cacheLocation) { auto path = BuildCachePath(schedule.year, schedule.month, schedule.day, - schedule.location, method); - std::ofstream out(path.c_str(), std::ios::binary | std::ios::trunc); - if (!out) return; + cacheLocation, method, school); + if (path.empty()) return; + std::ostringstream out; + out << std::setprecision(15); out << "{\n"; wchar_t dateBuf[16]; swprintf(dateBuf, 16, L"%04d-%02d-%02d", schedule.year, schedule.month, schedule.day); out << " \"Date\": \"" << WideToUtf8(dateBuf) << "\",\n"; - out << " \"FetchedAtUtc\": \"" << WideToUtf8(std::to_wstring(schedule.fetchedAtUtcMs)) << "\",\n"; + out << " \"FetchedAtUtcMs\": " << schedule.fetchedAtUtcMs << ",\n"; out << " \"Location\": {\n"; out << " \"Latitude\": " << schedule.location.latitude << ",\n"; out << " \"Longitude\": " << schedule.location.longitude << ",\n"; - out << " \"City\": \"" << WideToUtf8(schedule.location.city) << "\",\n"; - out << " \"Country\": \"" << WideToUtf8(schedule.location.country) << "\",\n"; - out << " \"Timezone\": \"" << WideToUtf8(schedule.location.timezone) << "\"\n"; + out << " \"City\": \"" << WideToUtf8(JsonEscape(schedule.location.city)) << "\",\n"; + out << " \"Country\": \"" << WideToUtf8(JsonEscape(schedule.location.country)) << "\",\n"; + out << " \"Timezone\": \"" << WideToUtf8(JsonEscape(schedule.location.timezone)) << "\"\n"; out << " },\n \"timings\": {\n"; for (size_t i = 0; i < schedule.prayers.size(); ++i) { const auto& p = schedule.prayers[i]; @@ -1814,18 +2026,32 @@ void SaveCache(const PrayerSchedule& schedule, int method) { out << "\n"; } out << " }\n}\n"; + if (!WriteTextFileAtomically(path, out.str())) { + Wh_Log(L"Failed to save prayer cache"); + } } -PrayerSchedule GetScheduleForDate(int year, int month, int day, LocationInfo loc) { - int method = ResolveCalculationMethod(loc); - if (auto cached = LoadCache(year, month, day, loc, method)) { +PrayerSchedule GetScheduleForDate(int year, int month, int day, + LocationInfo loc, int method, int school) { + auto cached = LoadCache(year, month, day, loc, method, school); + if (cached) { if (!IsCacheStale(*cached, year, month, day, loc)) { return *cached; } } - auto schedule = FetchScheduleFromApi(year, month, day, loc); - SaveCache(schedule, method); - return schedule; + try { + auto schedule = + FetchScheduleFromApi(year, month, day, loc, method, school); + SaveCache(schedule, method, school, loc); + return schedule; + } catch (...) { + if (cached && IsCompleteSchedule(*cached)) { + Wh_Log(L"Using stale prayer cache for %04d-%02d-%02d", year, + month, day); + return *cached; + } + throw; + } } void AddDays(SYSTEMTIME& st, int days) { @@ -1850,6 +2076,7 @@ std::optional GetNextPrayer() { auto consider = [&](const PrayerSchedule& sched) { for (const auto& p : sched.prayers) { ULONGLONG t = PrayerUnixSeconds(p); + if (!t) continue; if (t >= nowSec) { if (!found || t < bestSec) { best.name = p.name; @@ -1874,6 +2101,7 @@ std::vector GetTodayEntriesWithStatus() { const PrayerEntry* current = nullptr; for (const auto& p : g_currentSchedule.prayers) { ULONGLONG t = PrayerUnixSeconds(p); + if (!t) continue; if (nowSec >= t && nowSec < t + kCurrentPrayerHighlightMinutes * 60) { current = &p; @@ -1885,6 +2113,7 @@ std::vector GetTodayEntriesWithStatus() { auto considerNext = [&](const PrayerSchedule& sched) { for (const auto& p : sched.prayers) { ULONGLONG t = PrayerUnixSeconds(p); + if (!t) continue; if (t >= nowSec) { if (!hasNext || t < SystemTimeToUnixSeconds(nextInfo.time)) { nextInfo.name = p.name; @@ -1912,9 +2141,10 @@ std::vector GetTodayEntriesWithStatus() { } DisplayContent FormatTaskbarDisplay() { + const auto settings = GetSettingsSnapshot(); DisplayContent content; content.color = TaskbarTextColorHex(); - if (!g_settings.showOnTaskbar || g_isFullscreen.load()) { + if (!settings.showOnTaskbar || g_isFullscreen.load()) { content.visible = false; return content; } @@ -1924,18 +2154,18 @@ DisplayContent FormatTaskbarDisplay() { if (!next) { content.visible = true; if (g_lastRefreshFailed.load() && !g_refreshRunning.load()) { - content.top = StabilizeCompactText(Loc(L"Unavailable")); + content.top = StabilizeCompactText(L"--"); content.bottom = Loc(L"Prayer"); } else { content.top = StabilizeCompactText(L"..."); - content.bottom = Loc(L"Detecting"); + content.bottom = Loc(L"Prayer"); } g_uiTimerIntervalMs = slotReady ? 2000 : g_injectRetryMs.load(); return content; } content.visible = true; content.bottom = GetPrayerName(next->name); - switch (g_settings.contentMode) { + switch (settings.contentMode) { case ContentMode::Time: content.top = FormatTime(next->time); break; @@ -1965,6 +2195,20 @@ std::wstring GetNotificationSoundPath() { return base.empty() ? L"" : base + L"\\audio\\allah-akbar.mp3"; } +bool LooksLikeMp3(std::string_view data) { + if (data.size() < kNotificationSoundMinBytes || + data.size() > kNotificationSoundMaxBytes) { + return false; + } + if (data.size() >= 3 && data[0] == 'I' && data[1] == 'D' && + data[2] == '3') { + return true; + } + const auto b0 = static_cast(data[0]); + const auto b1 = static_cast(data[1]); + return b0 == 0xFF && (b1 & 0xE0) == 0xE0; +} + bool EnsureNotificationSoundFile() { const auto path = GetNotificationSoundPath(); if (path.empty()) { @@ -1979,31 +2223,33 @@ bool EnsureNotificationSoundFile() { ULARGE_INTEGER size{}; size.HighPart = attrs.nFileSizeHigh; size.LowPart = attrs.nFileSizeLow; - if (size.QuadPart == kNotificationSoundBytes) { - return true; + if (size.QuadPart >= kNotificationSoundMinBytes && + size.QuadPart <= kNotificationSoundMaxBytes) { + auto existing = + ReadTextFile(path, kNotificationSoundMaxBytes); + if (existing && LooksLikeMp3(*existing)) return true; } } - const auto body = HttpGetUtf8(kNotificationSoundUrl); - if (!body || body->size() != kNotificationSoundBytes) { + const auto body = + HttpGetUtf8(kNotificationSoundUrl, kNotificationSoundMaxBytes); + if (!body || !LooksLikeMp3(*body)) { Wh_Log(L"Notification sound download failed"); return false; } - std::ofstream out(path.c_str(), std::ios::binary | std::ios::trunc); - if (!out) { + if (!WriteTextFileAtomically(path, *body)) { Wh_Log(L"Notification sound write failed"); return false; } - out.write(body->data(), static_cast(body->size())); - return static_cast(out); + return true; } void PlayNotificationSound() { - if (!EnsureNotificationSoundFile()) { + const auto path = GetNotificationSoundPath(); + if (path.empty() || GetFileAttributesW(path.c_str()) == INVALID_FILE_ATTRIBUTES) { return; } - const auto path = GetNotificationSoundPath(); mciSendStringW(L"close prayertray_notify", nullptr, 0, nullptr); std::wstring openCmd = L"open \"" + path + L"\" type mpegvideo alias prayertray_notify"; @@ -2021,36 +2267,39 @@ void PlayNotificationSound() { } void CheckNotifications() { - if (!g_settings.playPrayerNotification) return; - std::lock_guard lock(g_scheduleMutex); - if (!g_hasCurrentSchedule) return; - int dateKey = DateKey(g_currentSchedule.year, g_currentSchedule.month, - g_currentSchedule.day); - if (g_notificationActiveDateKey != dateKey) { - g_notificationActiveDateKey = dateKey; - g_playedNotificationKeys.clear(); - } - ULONGLONG nowSec = LocalNowUnixSeconds(); - const ULONGLONG leadSec = - static_cast(kNotificationLeadMinutes * 60); - auto consider = [&](const PrayerSchedule& sched) { - const int schedKey = - DateKey(sched.year, sched.month, sched.day); - for (const auto& p : sched.prayers) { - ULONGLONG t = PrayerUnixSeconds(p); - if (nowSec + leadSec < t) continue; - if (nowSec >= t) continue; - wchar_t key[64]; - swprintf(key, 64, L"%d:%d", schedKey, static_cast(p.name)); - if (g_playedNotificationKeys.insert(key).second) { - PlayNotificationSound(); - return true; - } + if (!GetSettingsSnapshot().playPrayerNotification) return; + bool shouldPlay = false; + { + std::lock_guard lock(g_scheduleMutex); + if (!g_hasCurrentSchedule) return; + int dateKey = DateKey(g_currentSchedule.year, g_currentSchedule.month, + g_currentSchedule.day); + if (g_notificationActiveDateKey != dateKey) { + g_notificationActiveDateKey = dateKey; + g_playedNotificationKeys.clear(); } - return false; - }; - if (consider(g_currentSchedule)) return; - if (g_hasNextSchedule) consider(g_nextSchedule); + ULONGLONG nowSec = LocalNowUnixSeconds(); + const ULONGLONG leadSec = + static_cast(kNotificationLeadMinutes * 60); + auto consider = [&](const PrayerSchedule& sched) { + const int schedKey = DateKey(sched.year, sched.month, sched.day); + for (const auto& p : sched.prayers) { + ULONGLONG t = PrayerUnixSeconds(p); + if (!t) continue; + if (nowSec + leadSec < t || nowSec >= t) continue; + wchar_t key[64]; + swprintf(key, 64, L"%d:%d", schedKey, + static_cast(p.name)); + if (g_playedNotificationKeys.insert(key).second) { + return true; + } + } + return false; + }; + shouldPlay = consider(g_currentSchedule) || + (g_hasNextSchedule && consider(g_nextSchedule)); + } + if (shouldPlay) PlayNotificationSound(); } bool IsForegroundWindowFullscreen() { @@ -2105,16 +2354,29 @@ bool BootstrapFromCache() { } LocationInfo loc = *locOpt; + const auto settings = GetSettingsSnapshot(); + if (settings.useManualLocation) { + try { + loc = ResolveManualLocation(); + } catch (...) { + return false; + } + } else if (loc.source.starts_with(L"manual")) { + return false; + } SYSTEMTIME now = GetLocalNow(); - const int method = ResolveCalculationMethod(loc); - auto today = LoadCache(now.wYear, now.wMonth, now.wDay, loc, method); + const int method = ResolveCalculationMethod(loc, settings); + const int school = settings.hanafiAsr ? 1 : 0; + auto today = + LoadCache(now.wYear, now.wMonth, now.wDay, loc, method, school); if (!today || today->prayers.empty()) { return false; } SYSTEMTIME tomorrow = now; AddDays(tomorrow, 1); - auto nextDay = LoadCache(tomorrow.wYear, tomorrow.wMonth, tomorrow.wDay, loc, method); + auto nextDay = LoadCache(tomorrow.wYear, tomorrow.wMonth, tomorrow.wDay, + loc, method, school); { std::lock_guard lock(g_scheduleMutex); @@ -2132,18 +2394,26 @@ bool BootstrapFromCache() { return true; } -void RefreshSchedulesWorker() { - if (g_refreshRunning.exchange(true)) return; +bool RefreshSchedulesOnce(bool fullLocation) { + bool success = false; try { LocationInfo loc; - const bool fullLocation = g_forceLocationRefresh.exchange(false); - - if (g_settings.useManualLocation) { + const auto settings = GetSettingsSnapshot(); + if (settings.useManualLocation) { loc = ResolveManualLocation(); SaveLastLocation(loc); } else if (!fullLocation) { if (auto last = LoadLastLocation()) { - loc = *last; + const ULONGLONG now = GetUtcNowMs(); + const ULONGLONG maxAge = + static_cast(kLocationRefreshHours) * 3600000ULL; + if (!last->source.starts_with(L"manual") && + last->resolvedAtUtcMs && now >= last->resolvedAtUtcMs && + now - last->resolvedAtUtcMs <= maxAge) { + loc = *last; + } else { + loc = ResolveLocation(); + } } else { loc = ResolveLocation(); } @@ -2152,12 +2422,16 @@ void RefreshSchedulesWorker() { } SYSTEMTIME now = GetLocalNow(); - auto today = GetScheduleForDate(now.wYear, now.wMonth, now.wDay, loc); + const int method = ResolveCalculationMethod(loc, settings); + const int school = settings.hanafiAsr ? 1 : 0; + auto today = GetScheduleForDate(now.wYear, now.wMonth, now.wDay, loc, + method, school); SYSTEMTIME tomorrow = now; AddDays(tomorrow, 1); PrayerSchedule nextDay; try { - nextDay = GetScheduleForDate(tomorrow.wYear, tomorrow.wMonth, tomorrow.wDay, loc); + nextDay = GetScheduleForDate(tomorrow.wYear, tomorrow.wMonth, + tomorrow.wDay, loc, method, school); } catch (...) { } { @@ -2169,6 +2443,7 @@ void RefreshSchedulesWorker() { g_hasNextSchedule = !nextDay.prayers.empty(); } g_lastRefreshFailed = !g_hasCurrentSchedule; + success = g_hasCurrentSchedule; } catch (const std::exception& ex) { Wh_Log(L"Refresh failed: %S", ex.what()); g_lastRefreshFailed = true; @@ -2176,33 +2451,124 @@ void RefreshSchedulesWorker() { Wh_Log(L"Refresh failed"); g_lastRefreshFailed = true; } - g_refreshRunning = false; - g_refreshRequested = false; if (g_messageHwnd) { PostMessageW(g_messageHwnd, WM_PT_UI_TICK, 0, 0); } + return success; } -void RequestRefresh(bool fullLocation = false) { - if (fullLocation) { - g_forceLocationRefresh = true; +DWORD WINAPI RefreshThreadProc(void*) { + bool apartmentInitialized = false; + try { + winrt::init_apartment(winrt::apartment_type::multi_threaded); + apartmentInitialized = true; + } catch (...) { } - g_refreshRequested = true; - std::thread(RefreshSchedulesWorker).detach(); -} -void MaybeRequestScheduleRefresh() { - if (g_refreshRunning.load() || g_refreshRequested.load()) { - return; - } - SYSTEMTIME now = GetLocalNow(); - const int todayKey = DateKey(now.wYear, now.wMonth, now.wDay); + DWORD waitMs = INFINITE; + DWORD failureDelayMs = 60000; + HANDLE handles[] = {g_stopEvent, g_refreshWakeEvent}; + while (!StopRequested()) { + DWORD wait = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, + waitMs); + if (wait == WAIT_OBJECT_0 || StopRequested()) break; + if (wait != WAIT_OBJECT_0 + 1 && wait != WAIT_TIMEOUT) { + Wh_Log(L"Refresh worker wait failed (%u)", GetLastError()); + break; + } + + bool success = false; + do { + g_refreshRequested = false; + const bool fullLocation = g_forceLocationRefresh.exchange(false); + g_refreshRunning = true; + success = RefreshSchedulesOnce(fullLocation); + g_refreshRunning = false; + + const auto settings = GetSettingsSnapshot(); + bool soundReady = true; + if (settings.playPrayerNotification) { + soundReady = EnsureNotificationSoundFile(); + } + if (g_soundPreviewRequested.exchange(false) && soundReady && + g_messageHwnd) { + PostMessageW(g_messageHwnd, WM_PT_PLAY_SOUND, 0, 0); + } + } while (!StopRequested() && + (g_refreshRequested.exchange(false) || + g_forceLocationRefresh.load())); + + if (success) { + failureDelayMs = 60000; + waitMs = kScheduleRefreshIntervalMs; + } else { + waitMs = failureDelayMs; + failureDelayMs = (std::min)(failureDelayMs * 2, 15UL * 60UL * 1000UL); + } + } + g_refreshRunning = false; + if (apartmentInitialized) winrt::uninit_apartment(); + return 0; +} + +bool StartRefreshWorker() { + g_stopEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr); + g_refreshWakeEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr); + if (!g_stopEvent || !g_refreshWakeEvent) { + if (g_refreshWakeEvent) CloseHandle(g_refreshWakeEvent); + if (g_stopEvent) CloseHandle(g_stopEvent); + g_refreshWakeEvent = nullptr; + g_stopEvent = nullptr; + return false; + } + g_refreshThread = + CreateThread(nullptr, 0, RefreshThreadProc, nullptr, 0, nullptr); + if (!g_refreshThread) { + CloseHandle(g_refreshWakeEvent); + CloseHandle(g_stopEvent); + g_refreshWakeEvent = nullptr; + g_stopEvent = nullptr; + return false; + } + return true; +} + +void StopRefreshWorker() { + if (g_stopEvent) SetEvent(g_stopEvent); + if (g_refreshWakeEvent) SetEvent(g_refreshWakeEvent); + if (g_refreshThread) { + WaitForSingleObject(g_refreshThread, INFINITE); + CloseHandle(g_refreshThread); + g_refreshThread = nullptr; + } + if (g_refreshWakeEvent) { + CloseHandle(g_refreshWakeEvent); + g_refreshWakeEvent = nullptr; + } + if (g_stopEvent) { + CloseHandle(g_stopEvent); + g_stopEvent = nullptr; + } +} + +void RequestRefresh(bool fullLocation = false) { + if (fullLocation) { + g_forceLocationRefresh = true; + } + g_refreshRequested = true; + if (g_refreshWakeEvent) SetEvent(g_refreshWakeEvent); +} + +void MaybeRequestScheduleRefresh() { + if (g_refreshRunning.load() || g_refreshRequested.load()) { + return; + } + SYSTEMTIME now = GetLocalNow(); + const int todayKey = DateKey(now.wYear, now.wMonth, now.wDay); bool needsRefresh = false; { std::lock_guard lock(g_scheduleMutex); - if (!g_hasCurrentSchedule) { - needsRefresh = g_lastRefreshFailed.load(); - } else { + if (g_hasCurrentSchedule) { const int schedKey = DateKey(g_currentSchedule.year, g_currentSchedule.month, g_currentSchedule.day); needsRefresh = schedKey != todayKey; @@ -2277,81 +2643,7 @@ void UpdateTrayIcon(); void DestroyFlyout(); void DestroyWin10Overlay(); void RemoveTrayIcon(); -HWND FindCurrentProcessTaskbarWnd(); - -bool SlotUiReady() { - if (g_backend.load() == TaskbarBackend::Win11Xaml) { - return g_slotInjected.load() && g_slotRoot; - } - return g_win10OverlayHwnd != nullptr; -} - -bool ClaimExplorerRestartOnce() { - const auto base = GetAppDataPrayerTrayPath(); - if (base.empty()) { - return false; - } - CreateDirectoryW(base.c_str(), nullptr); - const std::wstring flag = base + L"\\explorer-restart.flag"; - - // CREATE_NEW: atomic one-shot. If the flag already exists, never restart again - // until the mod is disabled (flag cleared in Wh_ModBeforeUninit). - HANDLE h = CreateFileW(flag.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_NEW, - FILE_ATTRIBUTE_NORMAL, nullptr); - if (h == INVALID_HANDLE_VALUE) { - Wh_Log(L"Explorer restart skipped (already restarted once)"); - return false; - } - DWORD written = 0; - WriteFile(h, "1", 1, &written, nullptr); - CloseHandle(h); - return true; -} - -void ClearExplorerRestartFlag() { - const auto base = GetAppDataPrayerTrayPath(); - if (base.empty()) { - return; - } - DeleteFileW((base + L"\\explorer-restart.flag").c_str()); -} - -void ScheduleExplorerRestart() { - // Detached helper so we don't kill this explorer mid-call. - wchar_t cmd[] = - L"cmd.exe /d /c \"ping -n 2 127.0.0.1 >nul & " - L"taskkill /f /im explorer.exe >nul 2>&1 & start explorer.exe\""; - STARTUPINFOW si{}; - si.cb = sizeof(si); - PROCESS_INFORMATION pi{}; - if (!CreateProcessW(nullptr, cmd, nullptr, nullptr, FALSE, CREATE_NO_WINDOW, - nullptr, nullptr, &si, &pi)) { - Wh_Log(L"Failed to schedule explorer restart (%u)", GetLastError()); - return; - } - CloseHandle(pi.hThread); - CloseHandle(pi.hProcess); - Wh_Log(L"Scheduled explorer restart so the taskbar slot can inject"); -} - -void MaybeRestartExplorerForSlot() { - ApplyEngineToBackends(); - if (SlotUiReady()) { - // Slot worked — allow one restart again if the mod is later re-enabled - // and injection fails. Do not clear on unload: that would re-arm a loop - // when Explorer is killed for the restart itself. - ClearExplorerRestartFlag(); - return; - } - if (!FindCurrentProcessTaskbarWnd()) { - // Folder explorers have no tray — don't kill the shell for them. - return; - } - if (!ClaimExplorerRestartOnce()) { - return; - } - ScheduleExplorerRestart(); -} +void StopTimers(); void EnsureContextMenu() { if (g_contextMenu) return; @@ -2390,6 +2682,13 @@ void ShowContextMenu(HWND anchor) { } void DispatchCommand(int commandId) { + if (g_uiThreadId && GetCurrentThreadId() != g_uiThreadId) { + if (g_messageHwnd) { + PostMessageW(g_messageHwnd, WM_COMMAND, + static_cast(commandId), 0); + } + return; + } const auto now = GetTickCount64(); if (g_lastCommandId.load() == commandId && now - g_lastCommandTick.load() < 250) { return; @@ -2487,12 +2786,12 @@ LRESULT CALLBACK FlyoutWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam HDC hdc = BeginPaint(hWnd, &ps); RECT rc{}; GetClientRect(hWnd, &rc); - bool light = IsLightTheme(); - HBRUSH bg = CreateSolidBrush(light ? RGB(252, 252, 252) : RGB(32, 32, 32)); + const TaskbarPalette palette = GetTaskbarPalette(); + HBRUSH bg = CreateSolidBrush(palette.background); FillRect(hdc, &rc, bg); DeleteObject(bg); SetBkMode(hdc, TRANSPARENT); - SetTextColor(hdc, light ? RGB(26, 26, 26) : RGB(255, 255, 255)); + SetTextColor(hdc, palette.foreground); HFONT font = CreateFontW(-14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, @@ -2508,19 +2807,19 @@ LRESULT CALLBACK FlyoutWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam RECT titleRc{12, 8, rc.right - 12, 28}; DrawTextW(hdc, title.c_str(), -1, &titleRc, DT_LEFT | DT_SINGLELINE); RECT subRc{12, 28, rc.right - 12, 48}; - SetTextColor(hdc, light ? RGB(100, 100, 100) : RGB(180, 180, 180)); + SetTextColor(hdc, palette.secondary); DrawTextW(hdc, subtitle.c_str(), -1, &subRc, DT_LEFT | DT_SINGLELINE | DT_END_ELLIPSIS); auto entries = GetTodayEntriesWithStatus(); int y = kFlyoutHeaderHeight; for (const auto& e : entries) { RECT rowRc{12, y, rc.right - 12, y + kFlyoutRowHeight}; if (e.isCurrent || e.isNext) { - HBRUSH hl = CreateSolidBrush(light ? RGB(230, 240, 255) : RGB(50, 60, 80)); + HBRUSH hl = CreateSolidBrush(palette.highlight); RECT fillRc{0, y, rc.right, y + kFlyoutRowHeight}; FillRect(hdc, &fillRc, hl); DeleteObject(hl); } - SetTextColor(hdc, light ? RGB(26, 26, 26) : RGB(255, 255, 255)); + SetTextColor(hdc, palette.foreground); std::wstring name = GetPrayerName(e.name); std::wstring time = FormatTime(e.time); RECT nameRc{16, y + 4, rc.right / 2, y + kFlyoutRowHeight}; @@ -2529,6 +2828,9 @@ LRESULT CALLBACK FlyoutWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam DrawTextW(hdc, time.c_str(), -1, &timeRc, DT_RIGHT | DT_SINGLELINE); y += kFlyoutRowHeight; } + HBRUSH border = CreateSolidBrush(palette.border); + FrameRect(hdc, &rc, border); + DeleteObject(border); SelectObject(hdc, oldFont); DeleteObject(font); EndPaint(hWnd, &ps); @@ -2540,27 +2842,84 @@ LRESULT CALLBACK FlyoutWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam void EnsureFlyoutWindow() { if (g_flyoutHwnd) return; - static bool registered = false; - if (!registered) { + if (!g_flyoutClassRegistered) { WNDCLASSW wc{}; wc.lpfnWndProc = FlyoutWndProc; - wc.hInstance = GetModuleHandleW(nullptr); + wc.hInstance = g_moduleInstance; wc.lpszClassName = kFlyoutClass; wc.hbrBackground = nullptr; - RegisterClassW(&wc); - registered = true; + if (!RegisterClassW(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS) { + Wh_Log(L"Flyout class registration failed (%u)", GetLastError()); + return; + } + g_flyoutClassRegistered = true; } g_flyoutHwnd = CreateWindowExW( WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE, kFlyoutClass, L"", - WS_POPUP | WS_BORDER, 0, 0, kFlyoutWidth, + WS_POPUP, 0, 0, kFlyoutWidth, kFlyoutHeaderHeight + kFlyoutRowHeight * 5 + 8, g_messageHwnd, nullptr, - GetModuleHandleW(nullptr), nullptr); + g_moduleInstance, nullptr); + if (!g_flyoutHwnd) { + Wh_Log(L"Flyout window creation failed (%u)", GetLastError()); + } } bool TryGetSlotAnchor(RECT& anchor) { + if (g_backend.load() == TaskbarBackend::Win10Overlay && + g_win10OverlayHwnd && GetWindowRect(g_win10OverlayHwnd, &anchor)) { + return true; + } + const int slotW = 60, slotH = 40, gap = 4; HWND shell = FindCurrentProcessTaskbarWnd(); if (!shell) return false; + + if (g_backend.load() == TaskbarBackend::Win11Xaml && g_slotInjected.load()) { + struct AnchorState { + RECT rect{}; + std::atomic valid{false}; + }; + auto state = std::make_shared(); + const bool ran = RunFromWindowThread(shell, [state, shell]() { + try { + auto slot = g_slotRoot; + if (!slot) return; + auto xamlRoot = slot.XamlRoot(); + auto content = xamlRoot + ? xamlRoot.Content().try_as() + : nullptr; + if (!content || slot.ActualWidth() <= 0 || + slot.ActualHeight() <= 0) { + return; + } + const auto transform = slot.TransformToVisual(content); + const auto topLeft = transform.TransformPoint({0, 0}); + const auto bottomRight = transform.TransformPoint( + {static_cast(slot.ActualWidth()), + static_cast(slot.ActualHeight())}); + const double scale = xamlRoot.RasterizationScale(); + POINT origin{0, 0}; + if (!ClientToScreen(shell, &origin)) return; + RECT measured{ + origin.x + static_cast(std::lround(topLeft.X * scale)), + origin.y + static_cast(std::lround(topLeft.Y * scale)), + origin.x + static_cast(std::lround(bottomRight.X * scale)), + origin.y + static_cast(std::lround(bottomRight.Y * scale))}; + if (measured.right > measured.left && + measured.bottom > measured.top) { + state->rect = measured; + state->valid.store(true, std::memory_order_release); + } + } catch (...) { + } + }); + if (ran && state->valid.load(std::memory_order_acquire)) { + anchor = state->rect; + return true; + } + } + + // Compatibility fallback for classic taskbars or a tray that is rebuilding. HWND trayNotify = FindWindowExW(shell, nullptr, L"TrayNotifyWnd", nullptr); RECT notifyRect{}; if (trayNotify && GetWindowRect(trayNotify, ¬ifyRect)) { @@ -2589,13 +2948,37 @@ void ShowFlyout() { anchor.bottom = anchor.top + 40; } int height = kFlyoutHeaderHeight + kFlyoutRowHeight * 5 + 8; - int left = anchor.right - kFlyoutWidth; - int top = anchor.top - height - 8; HMONITOR mon = MonitorFromRect(&anchor, MONITOR_DEFAULTTONEAREST); MONITORINFO mi{sizeof(mi)}; - GetMonitorInfo(mon, &mi); - if (left < mi.rcWork.left + 8) left = mi.rcWork.left + 8; - if (top < mi.rcWork.top + 8) top = mi.rcWork.top + 8; + if (!GetMonitorInfo(mon, &mi)) return; + + constexpr int gap = 8; + constexpr int margin = 8; + const int centerX = anchor.left + (anchor.right - anchor.left) / 2; + const int centerY = anchor.top + (anchor.bottom - anchor.top) / 2; + const int distanceTop = centerY - mi.rcMonitor.top; + const int distanceBottom = mi.rcMonitor.bottom - centerY; + const int distanceLeft = centerX - mi.rcMonitor.left; + const int distanceRight = mi.rcMonitor.right - centerX; + const int nearestEdge = (std::min)({distanceTop, distanceBottom, + distanceLeft, distanceRight}); + + int left = centerX - kFlyoutWidth / 2; + int top = anchor.top - height - gap; + if (nearestEdge == distanceTop) { + top = anchor.bottom + gap; + } else if (nearestEdge == distanceLeft) { + left = anchor.right + gap; + top = centerY - height / 2; + } else if (nearestEdge == distanceRight) { + left = anchor.left - kFlyoutWidth - gap; + top = centerY - height / 2; + } + + left = std::clamp(left, static_cast(mi.rcWork.left) + margin, + static_cast(mi.rcWork.right) - kFlyoutWidth - margin); + top = std::clamp(top, static_cast(mi.rcWork.top) + margin, + static_cast(mi.rcWork.bottom) - height - margin); SetWindowPos(g_flyoutHwnd, HWND_TOPMOST, left, top, kFlyoutWidth, height, SWP_SHOWWINDOW | SWP_NOACTIVATE); InvalidateRect(g_flyoutHwnd, nullptr, TRUE); @@ -2618,12 +3001,17 @@ void DestroyFlyout() { DestroyWindow(g_flyoutHwnd); g_flyoutHwnd = nullptr; } + if (g_flyoutClassRegistered) { + UnregisterClassW(kFlyoutClass, g_moduleInstance); + g_flyoutClassRegistered = false; + } } void UpdateTrayIcon() { if (!g_messageHwnd) return; - if (g_settings.showNotificationIcon) { + const auto settings = GetSettingsSnapshot(); + if (settings.showNotificationIcon) { if (!g_trayIconAdded) { ZeroMemory(&g_trayIcon, sizeof(g_trayIcon)); g_trayIcon.cbSize = sizeof(g_trayIcon); @@ -2633,8 +3021,13 @@ void UpdateTrayIcon() { g_trayIcon.uCallbackMessage = WM_APP + 10; g_trayIcon.hIcon = LoadIconW(nullptr, IDI_APPLICATION); wcscpy_s(g_trayIcon.szTip, L"PrayerTray"); - Shell_NotifyIconW(NIM_ADD, &g_trayIcon); - g_trayIconAdded = true; + if (Shell_NotifyIconW(NIM_ADD, &g_trayIcon)) { + g_trayIcon.uVersion = NOTIFYICON_VERSION_4; + Shell_NotifyIconW(NIM_SETVERSION, &g_trayIcon); + g_trayIconAdded = true; + } else { + Wh_Log(L"Notification icon add failed (%u)", GetLastError()); + } } } else { RemoveTrayIcon(); @@ -2696,22 +3089,28 @@ LRESULT CALLBACK Win10OverlayProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPa void EnsureWin10Overlay() { if (g_backend.load() != TaskbarBackend::Win10Overlay) return; - static bool registered = false; - if (!registered) { + if (!g_overlayClassRegistered) { WNDCLASSW wc{}; wc.lpfnWndProc = Win10OverlayProc; - wc.hInstance = GetModuleHandleW(nullptr); + wc.hInstance = g_moduleInstance; wc.lpszClassName = kOverlayClass; wc.hCursor = LoadCursorW(nullptr, IDC_HAND); - RegisterClassW(&wc); - registered = true; + if (!RegisterClassW(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS) { + Wh_Log(L"Overlay class registration failed (%u)", GetLastError()); + return; + } + g_overlayClassRegistered = true; } HWND shell = FindCurrentProcessTaskbarWnd(); if (!shell) return; if (!g_win10OverlayHwnd) { g_win10OverlayHwnd = CreateWindowExW( WS_EX_TOOLWINDOW, kOverlayClass, L"", WS_CHILD | WS_VISIBLE, 0, 0, 60, - 40, shell, nullptr, GetModuleHandleW(nullptr), nullptr); + 40, shell, nullptr, g_moduleInstance, nullptr); + if (!g_win10OverlayHwnd) { + Wh_Log(L"Overlay window creation failed (%u)", GetLastError()); + return; + } } RepositionWin10Overlay(); } @@ -2738,6 +3137,10 @@ void RepositionWin10Overlay() { ScreenToClient(shell, &pt); cx = pt.x; cy = pt.y; + } else { + ShowWindow(g_win10OverlayHwnd, SW_HIDE); + g_lastOverlayShown = false; + return; } const bool show = g_win10Visible; if (g_hasOverlayPlacement && g_lastOverlayShown == show && @@ -2761,6 +3164,10 @@ void DestroyWin10Overlay() { g_win10OverlayHwnd = nullptr; } g_hasOverlayPlacement = false; + if (g_overlayClassRegistered) { + UnregisterClassW(kOverlayClass, g_moduleInstance); + g_overlayClassRegistered = false; + } } void ApplyWin10Content(const DisplayContent& content) { @@ -2874,8 +3281,17 @@ bool IsSlotRootAlive() { g_slotInjected = false; return false; } - // Do not require XamlRoot() here — it can be null for a moment after - // inject / during tray rebuild, and demoting then removes a live slot. + if (!g_slotRoot.XamlRoot() || + !Media::VisualTreeHelper::GetParent(g_slotRoot)) { + g_slotRoot = nullptr; + g_slotButton = nullptr; + g_topTextBlock = nullptr; + g_bottomTextBlock = nullptr; + g_slotParentGrid = nullptr; + g_slotInjected = false; + g_hasAppliedContent = false; + return false; + } return true; } catch (...) { g_slotInjected = false; @@ -2889,7 +3305,8 @@ void ApplySlotButtonVisualState() { uint8_t alpha = 0; if (g_slotPointerPressed.load()) alpha = 0x3A; else if (g_slotPointerOver.load()) alpha = 0x26; - button.Background(Brush(alpha, 255, 255, 255)); + const uint8_t channel = IsLightTheme() ? 0 : 255; + button.Background(Brush(alpha, channel, channel, channel)); } void ResetSlotButtonVisualState() { @@ -3016,7 +3433,12 @@ void RemovePrayerTraySlotFromGrid(Controls::Grid trayGrid) { auto child = children.GetAt(i).try_as(); if (!child) continue; int col = Controls::Grid::GetColumn(child); - if (col > slotColumn) Controls::Grid::SetColumn(child, col - 1); + int span = Controls::Grid::GetColumnSpan(child); + if (col > slotColumn) { + Controls::Grid::SetColumn(child, col - 1); + } else if (col < slotColumn && col + span > slotColumn && span > 1) { + Controls::Grid::SetColumnSpan(child, span - 1); + } } trayGrid.ColumnDefinitions().RemoveAt(slotColumn); } @@ -3071,11 +3493,15 @@ bool EnsurePrayerTraySlotInTrayGrid(Controls::Grid trayGrid) { topText.FontSize(11.5); topText.FlowDirection(FlowDirection::LeftToRight); topText.TextAlignment(TextAlignment::Center); + topText.MaxWidth(92); + topText.TextTrimming(TextTrimming::CharacterEllipsis); Controls::TextBlock bottomText; bottomText.Name(L"PrayerTrayBottom"); bottomText.FontFamily(Media::FontFamily(L"Segoe UI Variable Text")); bottomText.FontSize(11.5); bottomText.TextAlignment(TextAlignment::Center); + bottomText.MaxWidth(92); + bottomText.TextTrimming(TextTrimming::CharacterEllipsis); slotStack.Children().Append(topText); slotStack.Children().Append(bottomText); slotButton.Content(slotStack); @@ -3090,7 +3516,12 @@ bool EnsurePrayerTraySlotInTrayGrid(Controls::Grid trayGrid) { auto child = trayGrid.Children().GetAt(i).try_as(); if (!child) continue; int col = Controls::Grid::GetColumn(child); - if (col >= slotColumn) Controls::Grid::SetColumn(child, col + 1); + int span = Controls::Grid::GetColumnSpan(child); + if (col >= slotColumn) { + Controls::Grid::SetColumn(child, col + 1); + } else if (col < slotColumn && col + span > slotColumn) { + Controls::Grid::SetColumnSpan(child, span + 1); + } } } Controls::Grid::SetColumn(slotElement, slotColumn); @@ -3120,8 +3551,9 @@ bool EnsurePrayerTraySlot(FrameworkElement mainStack) { Padding="4,0,6,0" Margin="4,0,6,0" VerticalAlignment="Center"> + MaxWidth="92" TextTrimming="CharacterEllipsis" TextAlignment="Center"/> )"; auto slotButton = Markup::XamlReader::Load(xaml).try_as(); if (!slotButton) return false; @@ -3177,47 +3609,69 @@ bool ApplyWin11Style(XamlRoot xamlRoot, const DisplayContent& content) { return false; } -using RunFromWindowThreadProc_t = void(WINAPI*)(void*); +bool RunFromWindowThread(HWND hWnd, WindowThreadAction action, + DWORD timeoutMs) { + static const UINT message = + RegisterWindowMessageW(L"Windhawk_RunFromWindowThread_" WH_MOD_ID); + struct Payload { + WindowThreadAction action; + std::atomic ran{false}; + explicit Payload(WindowThreadAction value) : action(std::move(value)) {} + }; + using PayloadRef = std::shared_ptr; -bool RunFromWindowThread(HWND hWnd, RunFromWindowThreadProc_t proc, void* param) { - static const UINT msg = RegisterWindowMessage(L"Windhawk_RunFromWindowThread_" WH_MOD_ID); - struct Param { RunFromWindowThreadProc_t proc; void* param; }; - DWORD tid = GetWindowThreadProcessId(hWnd, nullptr); - if (!tid) return false; - if (tid == GetCurrentThreadId()) { + const DWORD threadId = GetWindowThreadProcessId(hWnd, nullptr); + if (!threadId || !action) return false; + if (threadId == GetCurrentThreadId()) { try { - proc(param); + action(); + return true; } catch (...) { + return false; } - return true; } + HHOOK hook = SetWindowsHookExW( WH_CALLWNDPROC, - [](int nCode, WPARAM wParam, LPARAM lParam) -> LRESULT { - if (nCode == HC_ACTION) { - const CWPSTRUCT* cwp = reinterpret_cast(lParam); - static const UINT m = RegisterWindowMessage(L"Windhawk_RunFromWindowThread_" WH_MOD_ID); - if (cwp->message == m) { - auto* p = reinterpret_cast(cwp->lParam); + [](int code, WPARAM wParam, LPARAM lParam) CALLBACK -> LRESULT { + if (code == HC_ACTION) { + const auto* cwp = reinterpret_cast(lParam); + static const UINT runMessage = RegisterWindowMessageW( + L"Windhawk_RunFromWindowThread_" WH_MOD_ID); + if (cwp->message == runMessage) { + std::unique_ptr holder( + reinterpret_cast(cwp->lParam)); + PayloadRef payload = *holder; try { - p->proc(p->param); + payload->action(); } catch (...) { } + payload->ran.store(true, std::memory_order_release); } } - return CallNextHookEx(nullptr, nCode, wParam, lParam); + return CallNextHookEx(nullptr, code, wParam, lParam); }, - nullptr, tid); + nullptr, threadId); if (!hook) return false; - Param p{proc, param}; - DWORD_PTR result = 0; - // Do not use SMTO_ABORTIFHUNG — tray layout often looks busy and aborted updates. - if (!SendMessageTimeoutW(hWnd, msg, 0, reinterpret_cast(&p), SMTO_NORMAL, - kRunFromWindowTimeoutMs, &result)) { - SendMessageW(hWnd, msg, 0, reinterpret_cast(&p)); + + PayloadRef payload = std::make_shared(std::move(action)); + auto* holder = new PayloadRef(payload); + DWORD_PTR ignored = 0; + const bool sent = + SendMessageTimeoutW(hWnd, message, 0, + reinterpret_cast(holder), + SMTO_ABORTIFHUNG | SMTO_BLOCK, timeoutMs, + &ignored) != 0; + const bool ran = payload->ran.load(std::memory_order_acquire); + if (!sent) { + // A timed-out send can still be consumed by Windows. The hook owns the + // heap holder in that case, which avoids a use-after-free during unload. + UnhookWindowsHookEx(hook); + return false; } + if (!ran) delete holder; UnhookWindowsHookEx(hook); - return true; + return ran; } HWND FindCurrentProcessTaskbarWnd() { @@ -3237,11 +3691,94 @@ HWND FindCurrentProcessTaskbarWnd() { return result; } -struct SlotApplyParam { DisplayContent content; }; +void* CTaskBand_ITaskListWndSite_vftable = nullptr; +using CTaskBand_GetTaskbarHost_t = void*(WINAPI*)(void*, void*); +CTaskBand_GetTaskbarHost_t CTaskBand_GetTaskbarHost_Original = nullptr; +using TaskbarHost_FrameHeight_t = int(WINAPI*)(void*); +TaskbarHost_FrameHeight_t TaskbarHost_FrameHeight_Original = nullptr; +using std__Ref_count_base__Decref_t = void(WINAPI*)(void*); +std__Ref_count_base__Decref_t std__Ref_count_base__Decref_Original = nullptr; + +HRESULT TryGetTaskbarElementAbi(HWND taskbar, void** result) { + if (!result) return E_POINTER; + *result = nullptr; + if (!taskbar || !CTaskBand_ITaskListWndSite_vftable || + !CTaskBand_GetTaskbarHost_Original || + !TaskbarHost_FrameHeight_Original || + !std__Ref_count_base__Decref_Original) { + return E_NOINTERFACE; + } + + HWND taskSwitch = + reinterpret_cast(GetPropW(taskbar, L"TaskbandHWND")); + if (!taskSwitch) return E_HANDLE; + void* taskBand = + reinterpret_cast(GetWindowLongPtrW(taskSwitch, 0)); + if (!taskBand) return E_POINTER; + + void* taskBandSite = taskBand; + for (int index = 0; + *reinterpret_cast(taskBandSite) != + CTaskBand_ITaskListWndSite_vftable; + ++index) { + if (index == 20) return E_NOINTERFACE; + taskBandSite = reinterpret_cast(taskBandSite) + 1; + } + + void* taskbarHostSharedPtr[2]{}; + CTaskBand_GetTaskbarHost_Original(taskBandSite, taskbarHostSharedPtr); + auto cleanup = [&]() { + if (taskbarHostSharedPtr[1]) { + std__Ref_count_base__Decref_Original(taskbarHostSharedPtr[1]); + taskbarHostSharedPtr[1] = nullptr; + } + }; + if (!taskbarHostSharedPtr[0]) { + cleanup(); + return E_POINTER; + } + + const BYTE* bytes = + reinterpret_cast(TaskbarHost_FrameHeight_Original); + if (bytes[0] != 0x48 || bytes[1] != 0x83 || bytes[2] != 0xEC || + bytes[4] != 0x48 || bytes[5] != 0x83 || bytes[6] != 0xC1 || + bytes[7] > 0x7F) { + cleanup(); + return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); + } + const size_t elementOffset = bytes[7]; + auto* elementUnknown = *reinterpret_cast( + reinterpret_cast(taskbarHostSharedPtr[0]) + elementOffset); + if (!elementUnknown) { + cleanup(); + return E_POINTER; + } + + const HRESULT hr = elementUnknown->QueryInterface( + winrt::guid_of(), result); + cleanup(); + return hr; +} + +XamlRoot GetTaskbarXamlRoot(HWND taskbar) { + void* elementAbi = nullptr; + if (FAILED(TryGetTaskbarElementAbi(taskbar, &elementAbi)) || + !elementAbi) { + return nullptr; + } + FrameworkElement element{nullptr}; + winrt::attach_abi(element, elementAbi); + return element ? element.XamlRoot() : nullptr; +} -void ApplyWin11FromThread(SlotApplyParam* param) { +struct SlotApplyParam { + HWND taskbar = nullptr; + DisplayContent content; +}; + +void ApplyWin11FromThread(const SlotApplyParam& param) { try { - DisplayContent content = param ? param->content : FormatTaskbarDisplay(); + const DisplayContent& content = param.content; try { if (IsSlotRootAlive()) { ApplyWin11SlotContent(content); @@ -3252,7 +3789,14 @@ void ApplyWin11FromThread(SlotApplyParam* param) { g_slotInjected = false; } bool injected = false; + try { + if (auto xamlRoot = GetTaskbarXamlRoot(param.taskbar)) { + injected = ApplyWin11Style(xamlRoot, content); + } + } catch (...) { + } for (auto it = g_observedElements.begin(); it != g_observedElements.end();) { + if (injected) break; auto element = it->get(); if (!element) { it = g_observedElements.erase(it); @@ -3260,10 +3804,8 @@ void ApplyWin11FromThread(SlotApplyParam* param) { } try { if (auto xr = element.XamlRoot()) { - if (ApplyWin11Style(xr, content)) { - injected = true; - break; - } + injected = ApplyWin11Style(xr, content); + break; } } catch (...) { } @@ -3282,6 +3824,14 @@ void ApplyWin11FromThread(SlotApplyParam* param) { // Stay aggressive at first (100→200→400), then back off to 1.5s max. const int cur = g_injectRetryMs.load(); g_injectRetryMs = std::min(1500, std::max(100, cur * 2)); + const ULONGLONG now = GetTickCount64(); + ULONGLONG next = g_nextInjectionFailureLogMs.load(); + if (now >= next && + g_nextInjectionFailureLogMs.compare_exchange_strong( + next, now + 30000)) { + Wh_Log(L"Win11 tray slot not ready (attempt %d, observed %zu)", + g_applySlotAttempts.load(), g_observedElements.size()); + } } } catch (...) { g_slotInjected = false; @@ -3294,8 +3844,12 @@ void TryApplyWin11Slot() { HWND taskbar = FindCurrentProcessTaskbarWnd(); if (!taskbar) return; DisplayContent content = FormatTaskbarDisplay(); - SlotApplyParam param{content}; - RunFromWindowThread(taskbar, [](void* p) { ApplyWin11FromThread(static_cast(p)); }, ¶m); + SlotApplyParam param{taskbar, content}; + if (!RunFromWindowThread(taskbar, + [param]() { ApplyWin11FromThread(param); })) { + const int current = g_injectRetryMs.load(); + g_injectRetryMs = (std::min)(1500, (std::max)(100, current * 2)); + } } void ApplyEngineToBackends() { @@ -3306,22 +3860,10 @@ void ApplyEngineToBackends() { } } -void* CTaskBand_ITaskListWndSite_vftable; -using CTaskBand_GetTaskbarHost_t = void*(WINAPI*)(void*, void**); -CTaskBand_GetTaskbarHost_t CTaskBand_GetTaskbarHost_Original; -void* TaskbarHost_FrameHeight_Original; -using std__Ref_count_base__Decref_t = void(WINAPI*)(void*); -std__Ref_count_base__Decref_t std__Ref_count_base__Decref_Original; - using IconView_IconView_t = void*(WINAPI*)(void*); -IconView_IconView_t IconView_IconView_Original; -using SystemTrayFrame_OnApplyTemplate_t = void(WINAPI*)(void*); -SystemTrayFrame_OnApplyTemplate_t SystemTrayFrame_OnApplyTemplate_Original; -using SystemTrayFrame_MeasureOverride_t = - winrt::Windows::Foundation::Size(WINAPI*)(void*, winrt::Windows::Foundation::Size const&); -SystemTrayFrame_MeasureOverride_t SystemTrayFrame_MeasureOverride_Original; +IconView_IconView_t IconView_IconView_Original = nullptr; using LoadLibraryExW_t = decltype(&LoadLibraryExW); -LoadLibraryExW_t LoadLibraryExW_Original; +LoadLibraryExW_t LoadLibraryExW_Original = nullptr; FrameworkElement TryGetFrameworkElementFromImplementation(void* pThis) { if (!pThis) return nullptr; @@ -3336,100 +3878,102 @@ FrameworkElement TryGetFrameworkElementFromImplementation(void* pThis) { return element; } -void TryApplySlotFromElement(FrameworkElement element) { - if (g_unloading || !element || g_backend.load() != TaskbarBackend::Win11Xaml) return; - try { - TrackObservedElement(element); - if (IsSlotRootAlive()) { - ApplyWin11SlotContent(FormatTaskbarDisplay()); - return; - } - if (auto xr = element.XamlRoot()) ApplyWin11Style(xr, FormatTaskbarDisplay()); - } catch (...) { - } -} - void* WINAPI IconView_IconView_Hook(void* pThis) { void* ret = IconView_IconView_Original(pThis); - if (!g_unloading) TryApplySlotFromElement(TryGetFrameworkElementFromImplementation(pThis)); + if (!g_unloading.load()) { + // Constructors run before the visual tree is ready. Keep only a weak + // reference and let the owned UI retry loop apply after layout settles. + if (auto element = TryGetFrameworkElementFromImplementation(pThis)) { + TrackObservedElement(element); + } + if (g_messageHwnd) { + PostMessageW(g_messageHwnd, WM_PT_UI_TICK, 0, 0); + } + } return ret; } -void WINAPI SystemTrayFrame_OnApplyTemplate_Hook(void* pThis) { - SystemTrayFrame_OnApplyTemplate_Original(pThis); - if (!g_unloading) TryApplySlotFromElement(TryGetFrameworkElementFromImplementation(pThis)); +VS_FIXEDFILEINFO* GetModuleVersionInfo(HMODULE module) { + void* fixedInfo = nullptr; + UINT length = 0; + HRSRC resource = + FindResourceW(module, MAKEINTRESOURCEW(VS_VERSION_INFO), RT_VERSION); + if (!resource) return nullptr; + HGLOBAL loaded = LoadResource(module, resource); + if (!loaded) return nullptr; + void* data = LockResource(loaded); + if (!data || !VerQueryValueW(data, L"\\", &fixedInfo, &length) || + length < sizeof(VS_FIXEDFILEINFO)) { + return nullptr; + } + return static_cast(fixedInfo); } -winrt::Windows::Foundation::Size WINAPI SystemTrayFrame_MeasureOverride_Hook( - void* pThis, winrt::Windows::Foundation::Size const& availableSize) { - auto result = SystemTrayFrame_MeasureOverride_Original(pThis, availableSize); - // Measure runs constantly during tray layout. Never touch an already-injected - // slot here, and debounce inject attempts so we don't fight layout. - if (g_unloading || IsSlotRootAlive()) { - return result; +HMODULE GetSystemTrayModuleHandle() { + if (HMODULE module = GetModuleHandleW(L"SystemTray.dll")) { + return module; } - const ULONGLONG now = GetTickCount64(); - const ULONGLONG last = g_lastMeasureInjectAttemptMs.load(); - // Fast retries right after enable; still avoid fighting every layout pass. - if (now - last < 200) { - return result; + if (HMODULE module = GetModuleHandleW(L"Taskbar.View.dll")) { + const auto* version = GetModuleVersionInfo(module); + const WORD major = version ? HIWORD(version->dwFileVersionMS) : 0; + if (major && major < 2604) return module; + return nullptr; } - g_lastMeasureInjectAttemptMs = now; - TryApplySlotFromElement(TryGetFrameworkElementFromImplementation(pThis)); - return result; + return GetModuleHandleW(L"ExplorerExtensions.dll"); } -HMODULE GetTaskbarViewModuleHandle() { - HMODULE m = GetModuleHandleW(L"Taskbar.View.dll"); - if (!m) m = GetModuleHandleW(L"ExplorerExtensions.dll"); - return m; -} - -bool HookTaskbarViewDllSymbols(HMODULE module) { +bool HookSystemTraySymbols(HMODULE module) { + // SystemTray.dll, Taskbar.View.dll, ExplorerExtensions.dll WindhawkUtils::SYMBOL_HOOK hooks[] = { {{LR"(public: __cdecl winrt::SystemTray::implementation::IconView::IconView(void))"}, - &IconView_IconView_Original, IconView_IconView_Hook, true}, - {{LR"(protected: virtual void __cdecl winrt::SystemTray::implementation::SystemTrayFrame::OnApplyTemplate(void))", - LR"(public: virtual void __cdecl winrt::SystemTray::implementation::SystemTrayFrame::OnApplyTemplate(void))"}, - &SystemTrayFrame_OnApplyTemplate_Original, SystemTrayFrame_OnApplyTemplate_Hook, true}, - {{LR"(protected: virtual struct winrt::Windows::Foundation::Size __cdecl winrt::SystemTray::implementation::SystemTrayFrame::MeasureOverride(struct winrt::Windows::Foundation::Size const &))", - LR"(public: virtual struct winrt::Windows::Foundation::Size __cdecl winrt::SystemTray::implementation::SystemTrayFrame::MeasureOverride(struct winrt::Windows::Foundation::Size const &))"}, - &SystemTrayFrame_MeasureOverride_Original, SystemTrayFrame_MeasureOverride_Hook, true}, + &IconView_IconView_Original, IconView_IconView_Hook}, }; - return HookSymbols(module, hooks, ARRAYSIZE(hooks)); + if (!HookSymbols(module, hooks, ARRAYSIZE(hooks))) { + Wh_Log(L"System tray symbol hook failed"); + return false; + } + return true; } -void HandleLoadedModuleIfTaskbarView(HMODULE module, LPCWSTR name) { - if (!g_taskbarViewDllLoaded && GetTaskbarViewModuleHandle() == module && - !g_taskbarViewDllLoaded.exchange(true)) { - Wh_Log(L"Loaded %s", name); - if (HookTaskbarViewDllSymbols(module)) Wh_ApplyHookOperations(); +void HandleLoadedModuleIfSystemTray(HMODULE module, LPCWSTR name) { + if (!g_systemTrayModuleHooked && GetSystemTrayModuleHandle() == module && + !g_systemTrayModuleHooked.exchange(true)) { + Wh_Log(L"Loaded system tray module: %s", name ? name : L"(unknown)"); + if (HookSystemTraySymbols(module)) { + Wh_ApplyHookOperations(); + } else { + g_systemTrayModuleHooked = false; + } } } HMODULE WINAPI LoadLibraryExW_Hook(LPCWSTR name, HANDLE file, DWORD flags) { HMODULE module = LoadLibraryExW_Original(name, file, flags); - if (module) HandleLoadedModuleIfTaskbarView(module, name); + if (module) HandleLoadedModuleIfSystemTray(module, name); return module; } bool HookTaskbarDllSymbols() { HMODULE module = LoadLibraryExW(L"taskbar.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32); - if (!module) return false; - WindhawkUtils::SYMBOL_HOOK hooks[] = { + if (!module) { + Wh_Log(L"taskbar.dll load failed (%u)", GetLastError()); + return false; + } + WindhawkUtils::SYMBOL_HOOK taskbarDllHooks[] = { {{LR"(const CTaskBand::`vftable'{for `ITaskListWndSite'})"}, &CTaskBand_ITaskListWndSite_vftable}, {{LR"(public: virtual class std::shared_ptr __cdecl CTaskBand::GetTaskbarHost(void)const )"}, &CTaskBand_GetTaskbarHost_Original}, {{LR"(public: int __cdecl TaskbarHost::FrameHeight(void)const )"}, &TaskbarHost_FrameHeight_Original}, {{LR"(public: void __cdecl std::_Ref_count_base::_Decref(void))"}, &std__Ref_count_base__Decref_Original}, }; - return HookSymbols(module, hooks, ARRAYSIZE(hooks)); + return HookSymbols(module, taskbarDllHooks, ARRAYSIZE(taskbarDllHooks)); } void SelectBackend() { - bool win11 = DetectWin11(); + const bool win11 = DetectWin11(); + const auto settings = GetSettingsSnapshot(); g_isWin11 = win11; - if (win11 && !g_settings.oldTaskbarOnWin11) { + if (win11 && !settings.oldTaskbarOnWin11) { g_backend = TaskbarBackend::Win11Xaml; } else { g_backend = TaskbarBackend::Win10Overlay; @@ -3439,6 +3983,7 @@ void SelectBackend() { void RestartUiTimer() { + if (!g_messageHwnd) return; const int intervalMs = g_uiTimerIntervalMs.load(); if (g_uiTimer && g_lastUiTimerIntervalMs == intervalMs) { return; @@ -3455,6 +4000,44 @@ VOID CALLBACK FullscreenTimerProc(HWND, UINT, UINT_PTR, DWORD) { } } +void ClearWin11Slot() { + try { + if (g_slotParentGrid) { + RemovePrayerTraySlotFromGrid(g_slotParentGrid); + } else if (g_slotRoot) { + g_slotRoot.Visibility(Visibility::Collapsed); + } + } catch (...) { + } + g_observedElements.clear(); + g_slotRoot = nullptr; + g_slotButton = nullptr; + g_topTextBlock = nullptr; + g_bottomTextBlock = nullptr; + g_slotParentGrid = nullptr; + g_slotInjected = false; + g_hasAppliedContent = false; +} + +void ShutdownOwnedUiResources() { + StopTimers(); + HideFlyout(); + DestroyFlyout(); + DestroyWin10Overlay(); + RemoveTrayIcon(); + if (g_contextMenu) { + DestroyMenu(g_contextMenu); + g_contextMenu = nullptr; + } + if (HWND taskbar = FindCurrentProcessTaskbarWnd()) { + if (!RunFromWindowThread(taskbar, ClearWin11Slot, 10000)) { + Wh_Log(L"Timed out while removing the Win11 taskbar slot"); + } + } else { + ClearWin11Slot(); + } +} + LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case WM_TIMER: @@ -3465,24 +4048,62 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara RestartUiTimer(); } else if (wParam == 2) { RepositionWin10Overlay(); - } else if (wParam == 4) { - RequestRefresh(false); } else if (wParam == 5 || wParam == 6 || wParam == 7) { // One-shot startup inject retries. KillTimer(hWnd, wParam); ApplyEngineToBackends(); - } else if (wParam == 8) { - KillTimer(hWnd, wParam); - MaybeRestartExplorerForSlot(); } return 0; case WM_PT_UI_TICK: - case WM_PT_REFRESH: ApplyEngineToBackends(); return 0; case WM_PT_HIDE_FLYOUT: HideFlyout(); return 0; + case WM_PT_AFTER_INIT: + ApplyEngineToBackends(); + SetTimer(hWnd, 5, 150, nullptr); + SetTimer(hWnd, 6, 400, nullptr); + SetTimer(hWnd, 7, 900, nullptr); + return 0; + case WM_PT_PLAY_SOUND: + PlayNotificationSound(); + return 0; + case WM_PT_SETTINGS_CHANGED: { + const auto oldBackend = static_cast(wParam); + const auto newBackend = g_backend.load(); + if (oldBackend != newBackend) { + if (newBackend == TaskbarBackend::Win10Overlay) { + if (HWND taskbar = FindCurrentProcessTaskbarWnd()) { + RunFromWindowThread( + taskbar, + []() { + try { + if (g_slotParentGrid) { + RemovePrayerTraySlotFromGrid( + g_slotParentGrid); + } else if (g_slotRoot) { + g_slotRoot.Visibility( + Visibility::Collapsed); + } + } catch (...) { + } + }); + } + } else { + DestroyWin10Overlay(); + } + } + UpdateTrayIcon(); + ApplyEngineToBackends(); + return 0; + } + case WM_PT_SHUTDOWN: + ShutdownOwnedUiResources(); + g_messageHwnd = nullptr; + DestroyWindow(hWnd); + PostQuitMessage(0); + return 0; case WM_APP + 10: switch (LOWORD(lParam)) { case WM_LBUTTONUP: @@ -3502,39 +4123,46 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara return DefWindowProcW(hWnd, msg, wParam, lParam); } -void EnsureMessageWindow() { - if (g_messageHwnd) return; - static bool reg = false; - if (!reg) { +bool EnsureMessageWindow() { + if (g_messageHwnd) return true; + if (!g_messageClassRegistered) { WNDCLASSW wc{}; wc.lpfnWndProc = MessageWndProc; - wc.hInstance = GetModuleHandleW(nullptr); + wc.hInstance = g_moduleInstance; wc.lpszClassName = L"PrayerTrayMessageWnd"; - RegisterClassW(&wc); - reg = true; + if (!RegisterClassW(&wc) && + GetLastError() != ERROR_CLASS_ALREADY_EXISTS) { + Wh_Log(L"Message window class registration failed (%u)", + GetLastError()); + return false; + } + g_messageClassRegistered = true; } g_messageHwnd = CreateWindowExW(0, L"PrayerTrayMessageWnd", L"PrayerTray", 0, 0, 0, 0, 0, - HWND_MESSAGE, nullptr, GetModuleHandleW(nullptr), nullptr); + HWND_MESSAGE, nullptr, g_moduleInstance, nullptr); + if (!g_messageHwnd) { + Wh_Log(L"Message window creation failed (%u)", GetLastError()); + return false; + } + return true; } void StartTimers() { - EnsureMessageWindow(); RestartUiTimer(); g_repositionTimer = SetTimer(g_messageHwnd, 2, 2000, nullptr); g_fullscreenTimer = SetTimer(nullptr, 3, 500, FullscreenTimerProc); - g_scheduleTimer = - SetTimer(g_messageHwnd, 4, kScheduleRefreshIntervalMs, nullptr); } void StopTimers() { if (g_messageHwnd) { KillTimer(g_messageHwnd, 1); KillTimer(g_messageHwnd, 2); - KillTimer(g_messageHwnd, 4); + KillTimer(g_messageHwnd, 5); + KillTimer(g_messageHwnd, 6); + KillTimer(g_messageHwnd, 7); } g_uiTimer = 0; g_repositionTimer = 0; - g_scheduleTimer = 0; g_lastUiTimerIntervalMs = -1; if (g_fullscreenTimer) { KillTimer(nullptr, g_fullscreenTimer); @@ -3542,104 +4170,202 @@ void StopTimers() { } } -void ClearWin11SlotOnUiThread(void*) { +DWORD WINAPI UiThreadProc(void*) { + bool apartmentInitialized = false; try { - if (g_slotParentGrid) { - RemovePrayerTraySlotFromGrid(g_slotParentGrid); - } else if (g_slotRoot) { - g_slotRoot.Visibility(Visibility::Collapsed); - } + winrt::init_apartment(winrt::apartment_type::multi_threaded); + apartmentInitialized = true; } catch (...) { } - g_observedElements.clear(); - g_slotRoot = nullptr; - g_slotButton = nullptr; - g_topTextBlock = nullptr; - g_bottomTextBlock = nullptr; - g_slotParentGrid = nullptr; - g_slotInjected = false; - g_hasAppliedContent = false; -} - -void ShutdownUi() { - StopTimers(); - HideFlyout(); - DestroyFlyout(); - DestroyWin10Overlay(); - RemoveTrayIcon(); - if (g_contextMenu) { - DestroyMenu(g_contextMenu); - g_contextMenu = nullptr; + g_uiThreadId = GetCurrentThreadId(); + const bool ready = EnsureMessageWindow(); + if (ready) { + StartTimers(); + UpdateTrayIcon(); + ApplyEngineToBackends(); } - if (HWND taskbar = FindCurrentProcessTaskbarWnd()) { - RunFromWindowThread(taskbar, ClearWin11SlotOnUiThread, nullptr); - } else { - try { - ClearWin11SlotOnUiThread(nullptr); - } catch (...) { + if (g_uiReadyEvent) SetEvent(g_uiReadyEvent); + if (!ready) { + if (g_messageClassRegistered) { + UnregisterClassW(L"PrayerTrayMessageWnd", g_moduleInstance); + g_messageClassRegistered = false; } + g_uiThreadId = 0; + if (apartmentInitialized) winrt::uninit_apartment(); + return 1; + } + + MSG message{}; + while (GetMessageW(&message, nullptr, 0, 0) > 0) { + TranslateMessage(&message); + DispatchMessageW(&message); } + if (g_messageHwnd) { + ShutdownOwnedUiResources(); DestroyWindow(g_messageHwnd); g_messageHwnd = nullptr; } + if (g_messageClassRegistered) { + UnregisterClassW(L"PrayerTrayMessageWnd", g_moduleInstance); + g_messageClassRegistered = false; + } + g_uiThreadId = 0; + if (apartmentInitialized) winrt::uninit_apartment(); + return 0; +} + +bool StartUiThread() { + g_uiReadyEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr); + if (!g_uiReadyEvent) return false; + g_uiThread = CreateThread(nullptr, 0, UiThreadProc, nullptr, 0, nullptr); + if (!g_uiThread) { + CloseHandle(g_uiReadyEvent); + g_uiReadyEvent = nullptr; + return false; + } + if (WaitForSingleObject(g_uiReadyEvent, INFINITE) != WAIT_OBJECT_0 || + !g_messageHwnd) { + if (g_uiThreadId) PostThreadMessageW(g_uiThreadId, WM_QUIT, 0, 0); + WaitForSingleObject(g_uiThread, INFINITE); + CloseHandle(g_uiThread); + CloseHandle(g_uiReadyEvent); + g_uiThread = nullptr; + g_uiReadyEvent = nullptr; + return false; + } + return true; +} + +void StopUiThread() { + if (g_messageHwnd) { + if (!PostMessageW(g_messageHwnd, WM_PT_SHUTDOWN, 0, 0) && + g_uiThreadId) { + PostThreadMessageW(g_uiThreadId, WM_QUIT, 0, 0); + } + } else if (g_uiThreadId) { + PostThreadMessageW(g_uiThreadId, WM_QUIT, 0, 0); + } + if (g_uiThread) { + WaitForSingleObject(g_uiThread, INFINITE); + CloseHandle(g_uiThread); + g_uiThread = nullptr; + } + if (g_uiReadyEvent) { + CloseHandle(g_uiReadyEvent); + g_uiReadyEvent = nullptr; + } +} + +bool IsShellExplorerProcess() { + const HWND shellWindow = GetShellWindow(); + if (!shellWindow) { + // Explorer can create the shell window slightly after process startup. + return true; + } + DWORD shellProcessId = 0; + GetWindowThreadProcessId(shellWindow, &shellProcessId); + return shellProcessId == GetCurrentProcessId(); } } // namespace BOOL Wh_ModInit() { - Wh_Log(L">"); + Wh_Log(L"PrayerTray 3.1.1 initializing"); + GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, + reinterpret_cast(&UiThreadProc), + &g_moduleInstance); + if (!g_moduleInstance || !IsShellExplorerProcess()) { + Wh_Log(L"Skipping non-shell explorer.exe process"); + return FALSE; + } + LoadSettings(); SelectBackend(); - EnsureMessageWindow(); - if (g_backend.load() == TaskbarBackend::Win11Xaml) { - HookTaskbarDllSymbols(); - if (HMODULE m = GetTaskbarViewModuleHandle()) { - g_taskbarViewDllLoaded = true; - HookTaskbarViewDllSymbols(m); - } else { - HMODULE kb = GetModuleHandleW(L"kernelbase.dll"); - auto pLoad = reinterpret_cast(GetProcAddress(kb, "LoadLibraryExW")); - WindhawkUtils::SetFunctionHook(pLoad, LoadLibraryExW_Hook, &LoadLibraryExW_Original); + + // Install Win11 hooks even when the compatibility overlay is currently + // selected, so changing that setting doesn't require restarting Explorer. + if (g_isWin11.load()) { + if (!HookTaskbarDllSymbols()) { + Wh_Log(L"taskbar.dll symbols unavailable; using IconView fallback"); + } + bool systemTrayHookReady = false; + if (HMODULE module = GetSystemTrayModuleHandle()) { + systemTrayHookReady = HookSystemTraySymbols(module); + g_systemTrayModuleHooked = systemTrayHookReady; + if (!systemTrayHookReady) { + Wh_Log(L"System tray hooks unavailable; watching for the current module"); + } + } + if (!systemTrayHookReady) { + HMODULE kernelBase = GetModuleHandleW(L"kernelbase.dll"); + auto loadLibraryEx = kernelBase + ? reinterpret_cast( + GetProcAddress(kernelBase, + "LoadLibraryExW")) + : nullptr; + if (loadLibraryEx) { + WindhawkUtils::SetFunctionHook(loadLibraryEx, + LoadLibraryExW_Hook, + &LoadLibraryExW_Original); + } else { + Wh_Log(L"LoadLibraryExW hook unavailable"); + } } } - // Never bail out of Wh_ModInit if Shell_TrayWnd is briefly missing (explorer - // restart / enable race). Slot inject already no-ops until the tray exists. - BootstrapFromCache(); + bool apartmentInitialized = false; + try { + winrt::init_apartment(winrt::apartment_type::multi_threaded); + apartmentInitialized = true; + } catch (...) { + // Explorer may already own this thread's COM apartment. + } + try { + BootstrapFromCache(); + } catch (...) { + Wh_Log(L"Cache bootstrap failed"); + } + if (apartmentInitialized) winrt::uninit_apartment(); g_injectRetryMs = 100; g_uiTimerIntervalMs = 100; - StartTimers(); - UpdateTrayIcon(); - ApplyEngineToBackends(); + if (!StartUiThread()) { + Wh_Log(L"UI thread startup failed"); + return FALSE; + } + if (!StartRefreshWorker()) { + Wh_Log(L"Refresh worker startup failed"); + StopUiThread(); + return FALSE; + } RequestRefresh(false); return TRUE; } void Wh_ModAfterInit() { Wh_Log(L">"); - if (g_backend.load() == TaskbarBackend::Win11Xaml && !g_taskbarViewDllLoaded) { - if (HMODULE m = GetTaskbarViewModuleHandle()) { - if (!g_taskbarViewDllLoaded.exchange(true)) { - if (HookTaskbarViewDllSymbols(m)) Wh_ApplyHookOperations(); + if (g_isWin11.load() && !g_systemTrayModuleHooked.load()) { + if (HMODULE module = GetSystemTrayModuleHandle()) { + if (!g_systemTrayModuleHooked.exchange(true)) { + if (HookSystemTraySymbols(module)) { + Wh_ApplyHookOperations(); + } else { + g_systemTrayModuleHooked = false; + } } } } - // Burst a few applies after hooks settle — first appearance should be quick. - ApplyEngineToBackends(); if (g_messageHwnd) { - PostMessageW(g_messageHwnd, WM_PT_UI_TICK, 0, 0); - SetTimer(g_messageHwnd, 5, 150, nullptr); - SetTimer(g_messageHwnd, 6, 400, nullptr); - SetTimer(g_messageHwnd, 7, 900, nullptr); - // If the slot still isn't there after retries, restart Explorer once. - SetTimer(g_messageHwnd, 8, 2500, nullptr); + PostMessageW(g_messageHwnd, WM_PT_AFTER_INIT, 0, 0); } } void Wh_ModBeforeUninit() { g_unloading = true; - ShutdownUi(); + StopRefreshWorker(); + StopUiThread(); + mciSendStringW(L"close prayertray_notify", nullptr, 0, nullptr); } void Wh_ModUninit() { @@ -3648,27 +4374,18 @@ void Wh_ModUninit() { void Wh_ModSettingsChanged() { Wh_Log(L"Settings changed"); - const bool wasSoundEnabled = g_settings.playPrayerNotification; - auto oldBackend = g_backend.load(); + const auto oldSettings = GetSettingsSnapshot(); + const auto oldBackend = g_backend.load(); LoadSettings(); SelectBackend(); - if (oldBackend != g_backend.load()) { - if (g_backend.load() == TaskbarBackend::Win10Overlay) { - if (auto root = g_slotRoot) { - try { - root.Visibility(Visibility::Collapsed); - } catch (...) { - } - } - } else { - DestroyWin10Overlay(); - } + const auto newSettings = GetSettingsSnapshot(); + if (!oldSettings.playPrayerNotification && + newSettings.playPrayerNotification) { + g_soundPreviewRequested = true; } - if (!wasSoundEnabled && g_settings.playPrayerNotification) { - PlayNotificationSound(); - } - UpdateTrayIcon(); - g_refreshRequested = true; RequestRefresh(true); - ApplyEngineToBackends(); + if (g_messageHwnd) { + PostMessageW(g_messageHwnd, WM_PT_SETTINGS_CHANGED, + static_cast(oldBackend), 0); + } } From 6d1f764e9a95e62379ee2aef912b44729297f854 Mon Sep 17 00:00:00 2001 From: omaralhami Date: Sun, 19 Jul 2026 06:58:11 +0300 Subject: [PATCH 10/10] Update PrayerTray to 3.1.4 --- mods/prayertray.wh.cpp | 220 ++++++++++++++++++----------------------- 1 file changed, 95 insertions(+), 125 deletions(-) diff --git a/mods/prayertray.wh.cpp b/mods/prayertray.wh.cpp index aedf30d26c..eda267188a 100644 --- a/mods/prayertray.wh.cpp +++ b/mods/prayertray.wh.cpp @@ -2,7 +2,7 @@ // @id prayertray // @name PrayerTray // @description Islamic prayer times on the taskbar, next to the clock. -// @version 3.1.1 +// @version 3.1.4 // @author Omar Alhami (mar) // @github https://github.com/n0tmar // @homepage https://github.com/n0tmar/PrayerTray @@ -16,7 +16,7 @@ # PrayerTray Shows the next Islamic prayer on the Windows taskbar so you can see it while -you work, without opening another app. Left-click opens today's times +you work, without opening another app. Left-click toggles today's times (Fajr, Dhuhr, Asr, Maghrib, Isha). Works on Windows 10 and 11. ## Location @@ -41,9 +41,6 @@ If you love this, you can support me on Patreon :) - showOnTaskbar: true $name: Show on taskbar $description: Show prayer text beside the clock -- showNotificationIcon: false - $name: Notification icon - $description: Optional icon in the notification area - playPrayerNotification: false $name: Prayer notification sound $description: Soft Allahu Akbar clip 1 minute before prayer time; plays a preview when enabled @@ -65,12 +62,6 @@ If you love this, you can support me on Patreon :) - calculationMethod: 0 $name: Calculation method $description: Leave at 0 for your country's default. Advanced users can set an Aladhan method number. -- asrSchool: standard - $name: Asr calculation - $description: Standard is used by Shafi, Maliki and Hanbali schools. Choose Hanafi for the later Asr time. - $options: - - standard: Standard - - hanafi: Hanafi - taskbarContentMode: smart $name: Taskbar text $description: Countdown, prayer clock time, or auto @@ -105,7 +96,7 @@ If you love this, you can support me on Patreon :) #endif #ifndef WH_MOD_VERSION -#define WH_MOD_VERSION L"3.1.1" +#define WH_MOD_VERSION L"3.1.4" #endif #include @@ -159,7 +150,10 @@ using namespace winrt::Windows::UI::Xaml; namespace { -constexpr wchar_t kColonRatio = L'\u2236'; +// A normal colon has the Unicode bidi class needed to keep hour:minute in +// order inside Arabic and Urdu text. U+2236 (ratio) is visually similar but +// can be reordered as a neutral character by GDI. +constexpr wchar_t kTimeColon = L':'; constexpr wchar_t kLre = L'\u202A'; constexpr wchar_t kPdf = L'\u202C'; constexpr int kNotificationLeadMinutes = 1; @@ -182,7 +176,6 @@ enum class ContentMode { Countdown, Time, Smart }; struct ModSettings { bool showOnTaskbar = true; - bool showNotificationIcon = false; bool playPrayerNotification = false; bool useManualLocation = false; std::wstring manualCity; @@ -190,7 +183,6 @@ struct ModSettings { std::wstring manualLatitude; std::wstring manualLongitude; int calculationMethod = 0; - bool hanafiAsr = false; ContentMode contentMode = ContentMode::Smart; bool use24Hour = false; std::wstring language = L"en"; @@ -282,10 +274,10 @@ UINT_PTR g_fullscreenTimer = 0; HWND g_win10OverlayHwnd = nullptr; HWND g_flyoutHwnd = nullptr; bool g_flyoutVisible = false; +RECT g_flyoutAnchorRect{}; +bool g_hasFlyoutAnchor = false; HHOOK g_flyoutMouseHook = nullptr; ULONGLONG g_flyoutSuppressDismissUntil = 0; -NOTIFYICONDATAW g_trayIcon{}; -bool g_trayIconAdded = false; HMENU g_contextMenu = nullptr; bool g_messageClassRegistered = false; bool g_flyoutClassRegistered = false; @@ -562,7 +554,6 @@ void LoadSettings() { ModSettings s; s.showOnTaskbar = Wh_GetIntSetting(L"showOnTaskbar") != 0; - s.showNotificationIcon = Wh_GetIntSetting(L"showNotificationIcon") != 0; s.playPrayerNotification = Wh_GetIntSetting(L"playPrayerNotification") != 0; s.useManualLocation = Wh_GetIntSetting(L"useManualLocation") != 0; s.manualCity = takeString(L"manualCity"); @@ -570,7 +561,6 @@ void LoadSettings() { s.manualLatitude = takeString(L"manualLatitude"); s.manualLongitude = takeString(L"manualLongitude"); s.calculationMethod = static_cast(Wh_GetIntSetting(L"calculationMethod")); - s.hanafiAsr = takeString(L"asrSchool") == L"hanafi"; s.contentMode = ParseContentMode(takeString(L"taskbarContentMode")); s.use24Hour = takeString(L"timeFormat") == L"24h"; s.language = takeString(L"language"); @@ -892,11 +882,11 @@ std::wstring StabilizeCompactText(const std::wstring& text) { std::wstring FormatTime(const SYSTEMTIME& time) { const auto settings = GetSettingsSnapshot(); - std::wstring text; + std::wstring numericTime; if (settings.use24Hour) { wchar_t buf[16]; - swprintf(buf, 16, L"%02u%c%02u", time.wHour, kColonRatio, time.wMinute); - text = buf; + swprintf(buf, 16, L"%02u%c%02u", time.wHour, kTimeColon, time.wMinute); + numericTime = buf; } else { int hour = time.wHour % 12; if (hour == 0) { @@ -904,18 +894,19 @@ std::wstring FormatTime(const SYSTEMTIME& time) { } const std::wstring period = time.wHour < 12 ? Loc(L"TimePeriod_AM") : Loc(L"TimePeriod_PM"); - wchar_t buf[32]; - // Arabic/Urdu: period on the left of the digits (ص 4:21), not 4:21 ص. + wchar_t buf[16]; + swprintf(buf, 16, L"%d%c%02u", hour, kTimeColon, time.wMinute); + numericTime = buf; if (IsRtlLanguage()) { - swprintf(buf, 32, L"%s %d%c%02u", period.c_str(), hour, kColonRatio, - time.wMinute); - } else { - swprintf(buf, 32, L"%d%c%02u %s", hour, kColonRatio, time.wMinute, - period.c_str()); + // Isolate only hour:minute as LTR. Keeping the Arabic/Urdu period + // outside the embedding prevents GDI from reversing 4:23 to 23:4. + return std::wstring(1, kLre) + numericTime + kPdf + L" " + period; } - text = buf; + return numericTime + L" " + period; } - return StabilizeCompactText(text); + return IsRtlLanguage() + ? std::wstring(1, kLre) + numericTime + kPdf + : numericTime; } std::wstring FormatCountdown(ULONGLONG seconds) { @@ -990,7 +981,7 @@ std::optional HttpGetUtf8(const std::wstring& url, return std::nullopt; } WinHttpHandle session(WinHttpOpen( - L"PrayerTray/3.1.1 (+https://github.com/n0tmar/PrayerTray)", + L"PrayerTray/3.1.4 (+https://github.com/n0tmar/PrayerTray)", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0)); if (!session) { @@ -1783,7 +1774,7 @@ bool IsCompleteSchedule(const PrayerSchedule& schedule) { } std::wstring BuildCachePath(int year, int month, int day, const LocationInfo& loc, - int method, int school) { + int method) { std::wstring key; if (loc.latitude != 0 || loc.longitude != 0) { wchar_t buf[64]; @@ -1794,14 +1785,14 @@ std::wstring BuildCachePath(int year, int month, int day, const LocationInfo& lo } key = SanitizeCachePart(key); wchar_t path[512]; - swprintf(path, 512, L"%04d-%02d-%02d_%s_m%d_s%d.json", year, month, - day, key.c_str(), method, school); + swprintf(path, 512, L"%04d-%02d-%02d_%s_m%d.json", year, month, day, + key.c_str(), method); const auto folder = GetCacheFolder(); return folder.empty() ? L"" : folder + L"\\" + path; } std::wstring BuildIslamicAppUrl(int year, int month, int day, const LocationInfo& loc, - int method, int school) { + int method) { SYSTEMTIME now = GetLocalNow(); std::wstring dateSegment; if (year == now.wYear && month == now.wMonth && day == now.wDay) { @@ -1815,11 +1806,11 @@ std::wstring BuildIslamicAppUrl(int year, int month, int day, const LocationInfo if (loc.source == L"manual-city") { auto cc = GetCountryCode(loc.country); url += L"city=" + UrlEncode(loc.city) + L"&country=" + cc + L"&method=" + - std::to_wstring(method) + L"&school=" + std::to_wstring(school); + std::to_wstring(method); } else { url += L"latitude=" + std::to_wstring(loc.latitude) + L"&longitude=" + - std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method) + - L"&school=" + std::to_wstring(school); + std::to_wstring(loc.longitude) + L"&method=" + + std::to_wstring(method); if (!loc.timezone.empty()) { url += L"&timezone=" + UrlEncode(loc.timezone); } @@ -1828,20 +1819,19 @@ std::wstring BuildIslamicAppUrl(int year, int month, int day, const LocationInfo } std::wstring BuildAladhanUrl(int year, int month, int day, const LocationInfo& loc, - int method, int school) { + int method) { wchar_t dateSeg[16]; swprintf(dateSeg, 16, L"%02d-%02d-%04d", day, month, year); std::wstring url; if (loc.source == L"manual-city") { url = L"https://api.aladhan.com/v1/timingsByCity/" + std::wstring(dateSeg) + L"?city=" + UrlEncode(loc.city) + L"&country=" + UrlEncode(loc.country) + - L"&method=" + std::to_wstring(method) + L"&school=" + - std::to_wstring(school); + L"&method=" + std::to_wstring(method); } else { url = L"https://api.aladhan.com/v1/timings/" + std::wstring(dateSeg) + L"?latitude=" + std::to_wstring(loc.latitude) + L"&longitude=" + - std::to_wstring(loc.longitude) + L"&method=" + std::to_wstring(method) + - L"&school=" + std::to_wstring(school); + std::to_wstring(loc.longitude) + L"&method=" + + std::to_wstring(method); if (!loc.timezone.empty()) { url += L"&timezonestring=" + UrlEncode(loc.timezone); } @@ -1850,8 +1840,7 @@ std::wstring BuildAladhanUrl(int year, int month, int day, const LocationInfo& l } PrayerSchedule FetchScheduleFromApi(int year, int month, int day, - LocationInfo loc, int method, - int school) { + LocationInfo loc, int method) { auto parseResponse = [&](const std::string& body) -> PrayerSchedule { auto data = JsonFindObject(body, "data"); if (!data) throw std::runtime_error("no data"); @@ -1870,13 +1859,13 @@ PrayerSchedule FetchScheduleFromApi(int year, int month, int day, return schedule; }; try { - auto url = BuildIslamicAppUrl(year, month, day, loc, method, school); + auto url = BuildIslamicAppUrl(year, month, day, loc, method); auto body = HttpGetUtf8(url); if (!body) throw std::runtime_error("islamic.app failed"); return parseResponse(*body); } catch (...) { Wh_Log(L"Primary prayer API failed; trying Aladhan"); - auto url = BuildAladhanUrl(year, month, day, loc, method, school); + auto url = BuildAladhanUrl(year, month, day, loc, method); auto body = HttpGetUtf8(url); if (!body) throw std::runtime_error("aladhan failed"); return parseResponse(*body); @@ -1899,9 +1888,8 @@ bool IsCacheStale(const PrayerSchedule& schedule, int y, int m, int d, } std::optional LoadCache(int year, int month, int day, - const LocationInfo& loc, int method, - int school) { - auto path = BuildCachePath(year, month, day, loc, method, school); + const LocationInfo& loc, int method) { + auto path = BuildCachePath(year, month, day, loc, method); auto contents = ReadTextFile(path, 256 * 1024); if (!contents) return std::nullopt; const std::string& json = *contents; @@ -1998,10 +1986,10 @@ std::optional LoadCache(int year, int month, int day, return schedule; } -void SaveCache(const PrayerSchedule& schedule, int method, int school, +void SaveCache(const PrayerSchedule& schedule, int method, const LocationInfo& cacheLocation) { auto path = BuildCachePath(schedule.year, schedule.month, schedule.day, - cacheLocation, method, school); + cacheLocation, method); if (path.empty()) return; std::ostringstream out; out << std::setprecision(15); @@ -2032,17 +2020,16 @@ void SaveCache(const PrayerSchedule& schedule, int method, int school, } PrayerSchedule GetScheduleForDate(int year, int month, int day, - LocationInfo loc, int method, int school) { - auto cached = LoadCache(year, month, day, loc, method, school); + LocationInfo loc, int method) { + auto cached = LoadCache(year, month, day, loc, method); if (cached) { if (!IsCacheStale(*cached, year, month, day, loc)) { return *cached; } } try { - auto schedule = - FetchScheduleFromApi(year, month, day, loc, method, school); - SaveCache(schedule, method, school, loc); + auto schedule = FetchScheduleFromApi(year, month, day, loc, method); + SaveCache(schedule, method, loc); return schedule; } catch (...) { if (cached && IsCompleteSchedule(*cached)) { @@ -2366,9 +2353,7 @@ bool BootstrapFromCache() { } SYSTEMTIME now = GetLocalNow(); const int method = ResolveCalculationMethod(loc, settings); - const int school = settings.hanafiAsr ? 1 : 0; - auto today = - LoadCache(now.wYear, now.wMonth, now.wDay, loc, method, school); + auto today = LoadCache(now.wYear, now.wMonth, now.wDay, loc, method); if (!today || today->prayers.empty()) { return false; } @@ -2376,7 +2361,7 @@ bool BootstrapFromCache() { SYSTEMTIME tomorrow = now; AddDays(tomorrow, 1); auto nextDay = LoadCache(tomorrow.wYear, tomorrow.wMonth, tomorrow.wDay, - loc, method, school); + loc, method); { std::lock_guard lock(g_scheduleMutex); @@ -2423,15 +2408,14 @@ bool RefreshSchedulesOnce(bool fullLocation) { SYSTEMTIME now = GetLocalNow(); const int method = ResolveCalculationMethod(loc, settings); - const int school = settings.hanafiAsr ? 1 : 0; auto today = GetScheduleForDate(now.wYear, now.wMonth, now.wDay, loc, - method, school); + method); SYSTEMTIME tomorrow = now; AddDays(tomorrow, 1); PrayerSchedule nextDay; try { nextDay = GetScheduleForDate(tomorrow.wYear, tomorrow.wMonth, - tomorrow.wDay, loc, method, school); + tomorrow.wDay, loc, method); } catch (...) { } { @@ -2481,19 +2465,24 @@ DWORD WINAPI RefreshThreadProc(void*) { do { g_refreshRequested = false; const bool fullLocation = g_forceLocationRefresh.exchange(false); - g_refreshRunning = true; - success = RefreshSchedulesOnce(fullLocation); - g_refreshRunning = false; + // Handle an enable-preview before any location or prayer API work. + // A cached clip therefore plays immediately after Apply, while a + // first-time download isn't delayed by the schedule refresh. const auto settings = GetSettingsSnapshot(); + const bool previewRequested = + g_soundPreviewRequested.exchange(false); bool soundReady = true; if (settings.playPrayerNotification) { soundReady = EnsureNotificationSoundFile(); } - if (g_soundPreviewRequested.exchange(false) && soundReady && - g_messageHwnd) { + if (previewRequested && soundReady && g_messageHwnd) { PostMessageW(g_messageHwnd, WM_PT_PLAY_SOUND, 0, 0); } + + g_refreshRunning = true; + success = RefreshSchedulesOnce(fullLocation); + g_refreshRunning = false; } while (!StopRequested() && (g_refreshRequested.exchange(false) || g_forceLocationRefresh.load())); @@ -2639,10 +2628,8 @@ void ShowContextMenu(HWND anchor); void ApplyEngineToBackends(); void EnsureWin10Overlay(); void RepositionWin10Overlay(); -void UpdateTrayIcon(); void DestroyFlyout(); void DestroyWin10Overlay(); -void RemoveTrayIcon(); void StopTimers(); void EnsureContextMenu() { @@ -2690,14 +2677,20 @@ void DispatchCommand(int commandId) { return; } const auto now = GetTickCount64(); - if (g_lastCommandId.load() == commandId && now - g_lastCommandTick.load() < 250) { + if (commandId != kCmdShowFlyout && + g_lastCommandId.load() == commandId && + now - g_lastCommandTick.load() < 250) { return; } g_lastCommandId = commandId; g_lastCommandTick = now; switch (commandId) { case kCmdShowFlyout: - ShowFlyout(); + if (g_flyoutVisible) { + HideFlyout(); + } else { + ShowFlyout(); + } break; case kCmdShowMenu: ShowContextMenu(g_win10OverlayHwnd ? g_win10OverlayHwnd @@ -2736,6 +2729,16 @@ LRESULT CALLBACK FlyoutMouseHookProc(int nCode, WPARAM wParam, LPARAM lParam) { if (GetWindowRect(g_flyoutHwnd, &rc)) { POINT pt{info->pt.x, info->pt.y}; if (!PtInRect(&rc, pt)) { + // A slot click is handled by DispatchCommand as a native + // toggle. Don't enqueue an outside-dismiss first, which + // would otherwise hide and immediately reopen the flyout. + if ((wParam == WM_LBUTTONDOWN || + wParam == WM_NCLBUTTONDOWN) && + g_hasFlyoutAnchor && + PtInRect(&g_flyoutAnchorRect, pt)) { + return CallNextHookEx(g_flyoutMouseHook, nCode, wParam, + lParam); + } if (g_messageHwnd) { PostMessageW(g_messageHwnd, WM_PT_HIDE_FLYOUT, 0, 0); } @@ -2770,6 +2773,12 @@ void InstallFlyoutDismissHook() { LRESULT CALLBACK FlyoutWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { + case WM_SETCURSOR: + if (LOWORD(lParam) == HTCLIENT) { + SetCursor(LoadCursorW(nullptr, IDC_ARROW)); + return TRUE; + } + break; case WM_ACTIVATE: if (LOWORD(wParam) == WA_INACTIVE) { HideFlyout(); @@ -2848,6 +2857,7 @@ void EnsureFlyoutWindow() { wc.hInstance = g_moduleInstance; wc.lpszClassName = kFlyoutClass; wc.hbrBackground = nullptr; + wc.hCursor = LoadCursorW(nullptr, IDC_ARROW); if (!RegisterClassW(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS) { Wh_Log(L"Flyout class registration failed (%u)", GetLastError()); return; @@ -2952,6 +2962,9 @@ void ShowFlyout() { MONITORINFO mi{sizeof(mi)}; if (!GetMonitorInfo(mon, &mi)) return; + g_flyoutAnchorRect = anchor; + g_hasFlyoutAnchor = true; + constexpr int gap = 8; constexpr int margin = 8; const int centerX = anchor.left + (anchor.right - anchor.left) / 2; @@ -2992,6 +3005,7 @@ void HideFlyout() { ShowWindow(g_flyoutHwnd, SW_HIDE); g_flyoutVisible = false; } + g_hasFlyoutAnchor = false; UninstallFlyoutDismissHook(); } @@ -3008,40 +3022,6 @@ void DestroyFlyout() { } -void UpdateTrayIcon() { - if (!g_messageHwnd) return; - const auto settings = GetSettingsSnapshot(); - if (settings.showNotificationIcon) { - if (!g_trayIconAdded) { - ZeroMemory(&g_trayIcon, sizeof(g_trayIcon)); - g_trayIcon.cbSize = sizeof(g_trayIcon); - g_trayIcon.hWnd = g_messageHwnd; - g_trayIcon.uID = 1; - g_trayIcon.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP; - g_trayIcon.uCallbackMessage = WM_APP + 10; - g_trayIcon.hIcon = LoadIconW(nullptr, IDI_APPLICATION); - wcscpy_s(g_trayIcon.szTip, L"PrayerTray"); - if (Shell_NotifyIconW(NIM_ADD, &g_trayIcon)) { - g_trayIcon.uVersion = NOTIFYICON_VERSION_4; - Shell_NotifyIconW(NIM_SETVERSION, &g_trayIcon); - g_trayIconAdded = true; - } else { - Wh_Log(L"Notification icon add failed (%u)", GetLastError()); - } - } - } else { - RemoveTrayIcon(); - } -} - -void RemoveTrayIcon() { - if (g_trayIconAdded) { - Shell_NotifyIconW(NIM_DELETE, &g_trayIcon); - g_trayIconAdded = false; - } -} - - constexpr wchar_t kOverlayClass[] = L"PrayerTrayOverlayWnd"; std::wstring g_win10Top; std::wstring g_win10Bottom; @@ -4024,7 +4004,6 @@ void ShutdownOwnedUiResources() { HideFlyout(); DestroyFlyout(); DestroyWin10Overlay(); - RemoveTrayIcon(); if (g_contextMenu) { DestroyMenu(g_contextMenu); g_contextMenu = nullptr; @@ -4070,6 +4049,9 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara PlayNotificationSound(); return 0; case WM_PT_SETTINGS_CHANGED: { + // Settings can rebuild the tray XAML. Close the transient flyout + // first so it never presents a stale or apparently busy surface. + HideFlyout(); const auto oldBackend = static_cast(wParam); const auto newBackend = g_backend.load(); if (oldBackend != newBackend) { @@ -4094,7 +4076,6 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara DestroyWin10Overlay(); } } - UpdateTrayIcon(); ApplyEngineToBackends(); return 0; } @@ -4104,16 +4085,6 @@ LRESULT CALLBACK MessageWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lPara DestroyWindow(hWnd); PostQuitMessage(0); return 0; - case WM_APP + 10: - switch (LOWORD(lParam)) { - case WM_LBUTTONUP: - DispatchCommand(kCmdShowFlyout); - break; - case WM_RBUTTONUP: - DispatchCommand(kCmdShowMenu); - break; - } - return 0; case WM_COMMAND: DispatchCommand(static_cast(LOWORD(wParam))); return 0; @@ -4181,7 +4152,6 @@ DWORD WINAPI UiThreadProc(void*) { const bool ready = EnsureMessageWindow(); if (ready) { StartTimers(); - UpdateTrayIcon(); ApplyEngineToBackends(); } if (g_uiReadyEvent) SetEvent(g_uiReadyEvent); @@ -4271,7 +4241,7 @@ bool IsShellExplorerProcess() { } // namespace BOOL Wh_ModInit() { - Wh_Log(L"PrayerTray 3.1.1 initializing"); + Wh_Log(L"PrayerTray 3.1.4 initializing"); GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, reinterpret_cast(&UiThreadProc), @@ -4374,13 +4344,13 @@ void Wh_ModUninit() { void Wh_ModSettingsChanged() { Wh_Log(L"Settings changed"); - const auto oldSettings = GetSettingsSnapshot(); const auto oldBackend = g_backend.load(); LoadSettings(); SelectBackend(); const auto newSettings = GetSettingsSnapshot(); - if (!oldSettings.playPrayerNotification && - newSettings.playPrayerNotification) { + // Windhawk invokes this callback after Save settings. Preview on every + // save while the option is enabled, not only on a false -> true change. + if (newSettings.playPrayerNotification) { g_soundPreviewRequested = true; } RequestRefresh(true);